Built with doc-gen4, running Lean4. Bubbles () indicate interactive fragments: hover for details, tap to reveal contents. Use Ctrl+↑Ctrl+↓to navigate, Ctrl+πŸ–±οΈto focus. On Mac, use Cmdinstead of Ctrl. 
import Mathlib.Data.Vector
import Mathlib.Data.Bitvec.Basic
import Mathlib.Algebra.Group.InjSurj
import Mathlib.Tactic.Ring
import Mathlib.Data.Int.Cast.Lemmas
import Mathlib.Data.ZMod.Basic

namespace Vector


instance: {Ξ± : Type u} β†’ {n : β„•} β†’ GetElem (Vector Ξ± n) (Fin n) Ξ± fun x x => True
instance {
Ξ±: Type u
Ξ± : 
Type u: Type (u+1)
Type u} {
n: β„•
n : 
Nat: Type
Nat} : 
GetElem: (cont : Type ?u.8) β†’
  (idx : Type ?u.7) β†’ outParam (Type ?u.6) β†’ outParam (cont β†’ idx β†’ Prop) β†’ Type (max(max?u.8?u.7)?u.6)
GetElem (
Vector: Type ?u.9 β†’ β„• β†’ Type ?u.9
Vector 
Ξ±: Type u
Ξ± 
n: β„•
n) (
Fin: β„• β†’ Type
Fin 
n: β„•
n) 
Ξ±: Type u
Ξ± (fun 
_: ?m.11
_ 
_: ?m.14
_ => 
True: Prop
True) where
  getElem := fun 
v: ?m.45
v 
i: ?m.48
i 
_: ?m.51
_ => 
v: ?m.45
v.
1: {Ξ± : Sort ?u.62} β†’ {p : Ξ± β†’ Prop} β†’ Subtype p β†’ Ξ±
1[
i: ?m.48
i.
val: {n : β„•} β†’ Fin n β†’ β„•
val]

@[simp]
theorem 
getElem_eq_get: βˆ€ {Ξ± : Type u} {n : β„•} (v : Vector Ξ± n) (i : Fin n), v[i] = get v i
getElem_eq_get {
Ξ±: Type u
Ξ± : 
Type u: Type (u+1)
Type u} {
n: β„•
n : 
Nat: Type
Nat} (
v: Vector Ξ± n
v : 
Vector: Type ?u.634 β†’ β„• β†’ Type ?u.634
Vector 
Ξ±: Type u
Ξ± 
n: β„•
n) (
i: Fin n
i : 
Fin: β„• β†’ Type
Fin 
n: β„•
n) : 
v: Vector Ξ± n
v[
i: Fin n
i] = 
v: Vector Ξ± n
v.
get: {Ξ± : Type ?u.689} β†’ {n : β„•} β†’ Vector Ξ± n β†’ Fin n β†’ Ξ±
get 
i: Fin n
i := 
rfl: βˆ€ {Ξ± : Sort ?u.817} {a : Ξ±}, a = a
rfl

end Vector

namespace Bitvec

def 
width: {n : β„•} β†’ Bitvec n β†’ β„•
width : 
Bitvec: β„• β†’ Type
Bitvec 
n: ?m.869
n β†’ 
Nat: Type
Nat := fun 
_: ?m.877
_ => 
n: β„•
n

-- Shouldn't this be inferred from the instance above? (as Bitvec is @[reducible])

instance: {n : β„•} β†’ GetElem (Bitvec n) (Fin n) Bool fun x x => True
instance {
n: β„•
n : 
Nat: Type
Nat} : 
GetElem: (cont : Type ?u.917) β†’
  (idx : Type ?u.916) β†’ outParam (Type ?u.915) β†’ outParam (cont β†’ idx β†’ Prop) β†’ Type (max(max?u.917?u.916)?u.915)
GetElem (
Bitvec: β„• β†’ Type
Bitvec 
n: β„•
n) (
Fin: β„• β†’ Type
Fin 
n: β„•
n) 
Bool: Type
Bool (fun 
_: ?m.919
_ 
_: ?m.922
_ => 
True: Prop
True) where
  getElem := fun 
v: ?m.948
v 
i: ?m.951
i 
_: ?m.954
_ => 
v: ?m.948
v.
1: {Ξ± : Sort ?u.965} β†’ {p : Ξ± β†’ Prop} β†’ Subtype p β†’ Ξ±
1[
i: ?m.951
i.
val: {n : β„•} β†’ Fin n β†’ β„•
val]


instance: (n : β„•) β†’ Inhabited (Bitvec n)
instance (
n: β„•
n : 
Nat: Type
Nat) : 
Inhabited: Sort ?u.1488 β†’ Sort (max1?u.1488)
Inhabited (
Bitvec: β„• β†’ Type
Bitvec 
n: β„•
n) :=
  ⟨
List.replicate: {Ξ± : Type ?u.1508} β†’ β„• β†’ Ξ± β†’ List Ξ±
List.replicate 
n: β„•
n 
true: Bool
true, 
Goals accomplished! πŸ™
n: β„•

List.length (List.replicate n true) = n
Goals accomplished! πŸ™
⟩

def 
Fun: (width : β„•) β†’ ?m.1584 width
Fun (
width: β„•
width : 
Nat: Type
Nat) := 
Fin: β„• β†’ Type
Fin 
width: β„•
width β†’ 
Bool: Type
Bool

def 
ofInt': (n : β„•) β†’ β„€ β†’ Bitvec n
ofInt' (
n: β„•
n : 
Nat: Type
Nat) (
z: β„€
z : 
Int: Type
Int) : 
Bitvec: β„• β†’ Type
Bitvec 
n: β„•
n :=
  match 
n: β„•
n with
    | 
0: β„•
0 => ⟨
List.nil: {Ξ± : Type ?u.1633} β†’ List Ξ±
List.nil, 
rfl: βˆ€ {Ξ± : Sort ?u.1636} {a : Ξ±}, a = a
rfl⟩
    | 
m: β„•
m + 1 => 
Bitvec.ofInt: (n : β„•) β†’ β„€ β†’ Bitvec (Nat.succ n)
Bitvec.ofInt 
m: β„•
m 
z: β„€
z

/-- convert `Bitvec n` to `Fin n β†’ Bool` -/
def 
ofFun: {width : β„•} β†’ Fun width β†’ Bitvec width
ofFun {
width: β„•
width : 
Nat: Type
Nat} : 
Fun: β„• β†’ Type
Fun 
width: β„•
width β†’ 
Bitvec: β„• β†’ Type
Bitvec 
width: β„•
width :=
  
Vector.ofFn: {Ξ± : Type ?u.1904} β†’ {n : β„•} β†’ (Fin n β†’ Ξ±) β†’ Vector Ξ± n
Vector.ofFn

/-- convert `Fin n β†’ Bool` to `Bitvec n` -/
def 
toFun: {width : β„•} β†’ Bitvec width β†’ Fun width
toFun {
width: β„•
width : 
Nat: Type
Nat} : 
Bitvec: β„• β†’ Type
Bitvec 
width: β„•
width β†’ 
Fun: β„• β†’ Type
Fun 
width: β„•
width :=
    
Vector.get: {Ξ± : Type ?u.1958} β†’ {n : β„•} β†’ Vector Ξ± n β†’ Fin n β†’ Ξ±
Vector.get


instance: {width : β„•} β†’ Coe (Fun width) (Bitvec width)
instance {
width: β„•
width : 
Nat: Type
Nat} : 
Coe: semiOutParam (Sort ?u.2016) β†’ Sort ?u.2015 β†’ Sort (max(max1?u.2016)?u.2015)
Coe (
Fun: β„• β†’ Type
Fun 
width: β„•
width) (
Bitvec: β„• β†’ Type
Bitvec 
width: β„•
width) := ⟨@
ofFun: {width : β„•} β†’ Fun width β†’ Bitvec width
ofFun 
width: β„•
width⟩

instance: {width : β„•} β†’ Coe (Bitvec width) (Fun width)
instance {
width: β„•
width : 
Nat: Type
Nat} : 
Coe: semiOutParam (Sort ?u.2097) β†’ Sort ?u.2096 β†’ Sort (max(max1?u.2097)?u.2096)
Coe (
Bitvec: β„• β†’ Type
Bitvec 
width: β„•
width) (
Fun: β„• β†’ Type
Fun 
width: β„•
width) := ⟨@
toFun: {width : β„•} β†’ Bitvec width β†’ Fun width
toFun 
width: β„•
width⟩

def 
ofVector: {n : β„•} β†’ Vector Bool n β†’ Bitvec n
ofVector : 
Vector: Type ?u.2179 β†’ β„• β†’ Type ?u.2179
Vector 
Bool: Type
Bool 
n: ?m.2175
n β†’ 
Bitvec: β„• β†’ Type
Bitvec 
n: ?m.2175
n := 
id: {Ξ± : Sort ?u.2185} β†’ Ξ± β†’ Ξ±
id

-- inspired by: https://leanprover.zulipchat.com/#narrow/stream/270676-lean4/topic/Defining.20my.20own.20numerals
-- not ideal solution, as hard to type, but should be ok for now
prefix:max "𝟢"   => fun v => 
ofVector: {n : β„•} β†’ Vector Bool n β†’ Bitvec n
ofVector (
Vector.cons: {Ξ± : Type u} β†’ {n : β„•} β†’ Ξ± β†’ Vector Ξ± n β†’ Vector Ξ± (Nat.succ n)
Vector.cons 
false: Bool
false v)
prefix:max "𝟷"   => fun v => 
ofVector: {n : β„•} β†’ Vector Bool n β†’ Bitvec n
ofVector (
Vector.cons: {Ξ± : Type u} β†’ {n : β„•} β†’ Ξ± β†’ Vector Ξ± n β†’ Vector Ξ± (Nat.succ n)
Vector.cons 
true: Bool
true v)
notation:max "𝟢"   => 
ofVector: {n : β„•} β†’ Vector Bool n β†’ Bitvec n
ofVector (
Vector.cons: {Ξ± : Type u} β†’ {n : β„•} β†’ Ξ± β†’ Vector Ξ± n β†’ Vector Ξ± (Nat.succ n)
Vector.cons 
false: Bool
false (@
Vector.nil: {Ξ± : Type u} β†’ Vector Ξ± 0
Vector.nil 
Bool: Type
Bool))
notation:max "𝟷"   => 
ofVector: {n : β„•} β†’ Vector Bool n β†’ Bitvec n
ofVector (
Vector.cons: {Ξ± : Type u} β†’ {n : β„•} β†’ Ξ± β†’ Vector Ξ± n β†’ Vector Ξ± (Nat.succ n)
Vector.cons 
true: Bool
true (@
Vector.nil: {Ξ± : Type u} β†’ Vector Ξ± 0
Vector.nil 
Bool: Type
Bool))


instance: {n : β„•} β†’ Add (Bitvec n)
instance : 
Add: Type ?u.125046 β†’ Type ?u.125046
Add (
Bitvec: β„• β†’ Type
Bitvec 
n: ?m.125043
n) where add := 
Bitvec.add: {n : β„•} β†’ Bitvec n β†’ Bitvec n β†’ Bitvec n
Bitvec.add

instance: {n : β„•} β†’ Sub (Bitvec n)
instance : 
Sub: Type ?u.125140 β†’ Type ?u.125140
Sub (
Bitvec: β„• β†’ Type
Bitvec 
n: ?m.125137
n) where sub := 
Bitvec.sub: {n : β„•} β†’ Bitvec n β†’ Bitvec n β†’ Bitvec n
Bitvec.sub

-- examples:
-- #eval (𝟷𝟢𝟷𝟷).toNat
-- #eval (𝟢𝟷𝟷𝟷).toNat
-- #eval (𝟢𝟷𝟷𝟷) + (𝟷𝟢𝟷𝟷) |>.toNat
-- #eval 𝟷𝟢𝟷𝟷 + 𝟢𝟷𝟷𝟷
-- #eval Bitvec.adc (𝟷𝟢𝟷𝟷) (𝟢𝟷𝟷𝟷) true
-- #eval Bitvec.adc (𝟷𝟢𝟷𝟷) (𝟢𝟷𝟷𝟷) false
-- #eval Bitvec.adc (𝟷𝟢𝟷𝟷) (𝟢𝟷𝟷𝟷) true |>.toNat
-- #eval Bitvec.adc (𝟷𝟢𝟷𝟷) (𝟢𝟷𝟷𝟷) false |>.toNat
-- 
-- #eval Bitvec.adc (𝟢) (𝟢) true
-- #eval Bitvec.adc (𝟢) (𝟢) false

def 
toZMod: {n : β„•} β†’ Bitvec n β†’ ZMod (2 ^ n)
toZMod {
n: β„•
n : 
Nat: Type
Nat} (
x: Bitvec n
x : 
Bitvec: β„• β†’ Type
Bitvec 
n: β„•
n) : 
ZMod: β„• β†’ Type
ZMod (
2: ?m.125237
2 ^ 
n: β„•
n) := 
  
x: Bitvec n
x.
toNat: {n : β„•} β†’ Bitvec n β†’ β„•
toNat

theorem 
toZMod_val: βˆ€ {n : β„•} (v : Bitvec n), ZMod.val (toZMod v) = Bitvec.toNat v
toZMod_val {
n: β„•
n : 
β„•: Type
β„•} (
v: Bitvec n
v : 
Bitvec: β„• β†’ Type
Bitvec 
n: β„•
n) : (
toZMod: {n : β„•} β†’ Bitvec n β†’ ZMod (2 ^ n)
toZMod 
v: Bitvec n
v).
val: {n : β„•} β†’ ZMod n β†’ β„•
val = 
v: Bitvec n
v.
toNat: {n : β„•} β†’ Bitvec n β†’ β„•
toNat := 
Goals accomplished! πŸ™
n: β„•

v: Bitvec n

ZMod.val (toZMod v) = Bitvec.toNat v
n: β„•

v: Bitvec n

ZMod.val (toZMod v) = Bitvec.toNat v
n: β„•

v: Bitvec n

ZMod.val ↑(Bitvec.toNat v) = Bitvec.toNat v
n: β„•

v: Bitvec n

ZMod.val (toZMod v) = Bitvec.toNat v
n: β„•

v: Bitvec n

Bitvec.toNat v % 2 ^ n = Bitvec.toNat v
n: β„•

v: Bitvec n

ZMod.val (toZMod v) = Bitvec.toNat v
n: β„•

v: Bitvec n

Bitvec.toNat v = Bitvec.toNat v
n: β„•

v: Bitvec n

Bitvec.toNat v < 2 ^ n
n: β„•

v: Bitvec n

Bitvec.toNat v < 2 ^ n
n: β„•

v: Bitvec n

ZMod.val (toZMod v) = Bitvec.toNat v
Goals accomplished! πŸ™


def 
ofZMod: {n : β„•} β†’ ZMod (2 ^ n) β†’ Bitvec n
ofZMod {
n: β„•
n : 
β„•: Type
β„•} (
x: ZMod (2 ^ n)
x : 
ZMod: β„• β†’ Type
ZMod (
2: ?m.125994
2 ^ 
n: β„•
n)) : 
Bitvec: β„• β†’ Type
Bitvec 
n: β„•
n := 
  
Bitvec.ofNat: (n : β„•) β†’ β„• β†’ Bitvec n
Bitvec.ofNat 
_: β„•
_ 
x: ZMod (2 ^ n)
x.
val: {n : β„•} β†’ ZMod n β†’ β„•
val

theorem 
toZMod_ofZMod: βˆ€ {n : β„•} (i : ZMod (2 ^ n)), toZMod (ofZMod i) = i
toZMod_ofZMod {
n: ?m.126151
n} (
i: ZMod (2 ^ n)
i : 
ZMod: β„• β†’ Type
ZMod <| 
2: ?m.126158
2 ^ 
n: ?m.126151
n) : (
ofZMod: {n : β„•} β†’ ZMod (2 ^ n) β†’ Bitvec n
ofZMod 
i: ZMod (2 ^ n)
i).
toZMod: {n : β„•} β†’ Bitvec n β†’ ZMod (2 ^ n)
toZMod = 
i: ZMod (2 ^ n)
i :=
  
ZMod.val_injective: βˆ€ (n : β„•) [inst : NeZero n], Function.Injective ZMod.val
ZMod.val_injective 
_: β„•
_ (
Goals accomplished! πŸ™
n: β„•

i: ZMod (2 ^ n)

ZMod.val (toZMod (ofZMod i)) = ZMod.val i
Goals accomplished! πŸ™
)

theorem 
ofZMod_toZMod: βˆ€ {n : β„•} (v : Bitvec n), ofZMod (toZMod v) = v
ofZMod_toZMod {
n: β„•
n} (
v: Bitvec n
v : 
Bitvec: β„• β†’ Type
Bitvec 
n: ?m.126550
n) : 
ofZMod: {n : β„•} β†’ ZMod (2 ^ n) β†’ Bitvec n
ofZMod (
toZMod: {n : β„•} β†’ Bitvec n β†’ ZMod (2 ^ n)
toZMod 
v: Bitvec n
v) = 
v: Bitvec n
v := 
Goals accomplished! πŸ™
n: β„•

v: Bitvec n

ofZMod (toZMod v) = v
n: β„•

v: Bitvec n

Bitvec.ofNat n (ZMod.val (toZMod v)) = v
n: β„•

v: Bitvec n

ofZMod (toZMod v) = v
n: β„•

v: Bitvec n

Bitvec.ofNat n (ZMod.val (toZMod v)) = v
n: β„•

v: Bitvec n

Bitvec.ofNat n (Bitvec.toNat v) = v
n: β„•

v: Bitvec n

Bitvec.ofNat n (ZMod.val (toZMod v)) = v
n: β„•

v: Bitvec n

v = v
Goals accomplished! πŸ™


theorem 
foldl_addLsb_add: βˆ€ (n k : β„•) (x : List Bool), List.foldl addLsb (n + k) x = 2 ^ List.length x * k + List.foldl addLsb n x
foldl_addLsb_add : βˆ€ (
n: β„•
n 
k: β„•
k : 
β„•: Type
β„•) (
x: List Bool
x : 
List: Type ?u.126633 β†’ Type ?u.126633
List 
Bool: Type
Bool), 
    
x: List Bool
x.
foldl: {Ξ± : Type ?u.126638} β†’ {Ξ² : Type ?u.126637} β†’ (Ξ± β†’ Ξ² β†’ Ξ±) β†’ Ξ± β†’ List Ξ² β†’ Ξ±
foldl 
addLsb: β„• β†’ Bool β†’ β„•
addLsb (
n: β„•
n + 
k: β„•
k) = 
2: ?m.126703
2 ^ 
x: List Bool
x.
length: {Ξ± : Type ?u.126712} β†’ List Ξ± β†’ β„•
length * 
k: β„•
k + 
x: List Bool
x.
foldl: {Ξ± : Type ?u.126717} β†’ {Ξ² : Type ?u.126716} β†’ (Ξ± β†’ Ξ² β†’ Ξ±) β†’ Ξ± β†’ List Ξ² β†’ Ξ±
foldl 
addLsb: β„• β†’ Bool β†’ β„•
addLsb 
n: β„•
n
  | 
n: β„•
n, 
k: β„•
k, [] => 
Goals accomplished! πŸ™
n, k: β„•

List.foldl addLsb (n + k) [] = 2 ^ List.length [] * k + List.foldl addLsb n []
Goals accomplished! πŸ™

  | 
n: β„•
n, 
k: β„•
k, 
a: Bool
a::
l: List Bool
l => 
Goals accomplished! πŸ™
n, k: β„•

a: Bool

l: List Bool

List.foldl addLsb (n + k) (a :: l) = 2 ^ List.length (a :: l) * k + List.foldl addLsb n (a :: l)
n, k: β„•

a: Bool

l: List Bool

List.foldl addLsb (n + k) (a :: l) = 2 ^ List.length (a :: l) * k + List.foldl addLsb n (a :: l)
n, k: β„•

a: Bool

l: List Bool

List.foldl addLsb (addLsb (n + k) a) l = 2 ^ List.length (a :: l) * k + List.foldl addLsb n (a :: l)
n, k: β„•

a: Bool

l: List Bool

List.foldl addLsb (n + k) (a :: l) = 2 ^ List.length (a :: l) * k + List.foldl addLsb n (a :: l)
n, k: β„•

a: Bool

l: List Bool

List.foldl addLsb (addLsb (n + k) a) l = 2 ^ List.length (a :: l) * k + List.foldl addLsb (addLsb n a) l
n, k: β„•

a: Bool

l: List Bool

List.foldl addLsb (n + k) (a :: l) = 2 ^ List.length (a :: l) * k + List.foldl addLsb n (a :: l)
n, k: β„•

a: Bool

l: List Bool

List.foldl addLsb (n + k + (n + k) + bif a then 1 else 0) l =   2 ^ List.length (a :: l) * k + List.foldl addLsb (addLsb n a) l
n, k: β„•

a: Bool

l: List Bool

List.foldl addLsb (n + k) (a :: l) = 2 ^ List.length (a :: l) * k + List.foldl addLsb n (a :: l)
n, k: β„•

a: Bool

l: List Bool

List.foldl addLsb (n + k + (n + k) + bif a then 1 else 0) l =   2 ^ List.length (a :: l) * k + List.foldl addLsb (n + n + bif a then 1 else 0) l
n, k: β„•

a: Bool

l: List Bool

List.foldl addLsb (n + k + (n + k) + bif a then 1 else 0) l =   2 ^ List.length (a :: l) * k + List.foldl addLsb (n + n + bif a then 1 else 0) l
n, k: β„•

a: Bool

l: List Bool

List.foldl addLsb (n + k) (a :: l) = 2 ^ List.length (a :: l) * k + List.foldl addLsb n (a :: l)
n, k: β„•

a: Bool

l: List Bool

List.foldl addLsb (n + k + (n + k) + bif a then 1 else 0) l =   2 ^ List.length (a :: l) * k + List.foldl addLsb (n + n + bif a then 1 else 0) l
Goals accomplished! πŸ™
n, k: β„•

a: Bool

l: List Bool

(n + k + (n + k) + bif a then 1 else 0) = (n + n + bif a then 1 else 0) + (k + k)
Goals accomplished! πŸ™
n, k: β„•

a: Bool

l: List Bool

List.foldl addLsb (n + k) (a :: l) = 2 ^ List.length (a :: l) * k + List.foldl addLsb n (a :: l)
n, k: β„•

a: Bool

l: List Bool

this: (n + k + (n + k) + bif a then 1 else 0) = (n + n + bif a then 1 else 0) + (k + k)

List.foldl addLsb (n + k + (n + k) + bif a then 1 else 0) l =   2 ^ List.length (a :: l) * k + List.foldl addLsb (n + n + bif a then 1 else 0) l
n, k: β„•

a: Bool

l: List Bool

this: (n + k + (n + k) + bif a then 1 else 0) = (n + n + bif a then 1 else 0) + (k + k)

List.foldl addLsb ((n + n + bif a then 1 else 0) + (k + k)) l =   2 ^ List.length (a :: l) * k + List.foldl addLsb (n + n + bif a then 1 else 0) l
n, k: β„•

a: Bool

l: List Bool

this: (n + k + (n + k) + bif a then 1 else 0) = (n + n + bif a then 1 else 0) + (k + k)

List.foldl addLsb (n + k + (n + k) + bif a then 1 else 0) l =   2 ^ List.length (a :: l) * k + List.foldl addLsb (n + n + bif a then 1 else 0) l
n, k: β„•

a: Bool

l: List Bool

this: (n + k + (n + k) + bif a then 1 else 0) = (n + n + bif a then 1 else 0) + (k + k)

2 ^ List.length l * (k + k) + List.foldl addLsb (n + n + bif a then 1 else 0) l =   2 ^ List.length (a :: l) * k + List.foldl addLsb (n + n + bif a then 1 else 0) l
n, k: β„•

a: Bool

l: List Bool

this: (n + k + (n + k) + bif a then 1 else 0) = (n + n + bif a then 1 else 0) + (k + k)

2 ^ List.length l * (k + k) + List.foldl addLsb (n + n + bif a then 1 else 0) l =   2 ^ List.length (a :: l) * k + List.foldl addLsb (n + n + bif a then 1 else 0) l
n, k: β„•

a: Bool

l: List Bool

List.foldl addLsb (n + k) (a :: l) = 2 ^ List.length (a :: l) * k + List.foldl addLsb n (a :: l)
Goals accomplished! πŸ™


theorem 
foldl_addLsb_eq_add_foldl_addLsb_zero: βˆ€ (x : List Bool) (k : β„•), List.foldl addLsb k x = 2 ^ List.length x * k + List.foldl addLsb 0 x
foldl_addLsb_eq_add_foldl_addLsb_zero (
x: List Bool
x : 
List: Type ?u.129331 β†’ Type ?u.129331
List 
Bool: Type
Bool) (
k: β„•
k : 
β„•: Type
β„•) :
    
x: List Bool
x.
foldl: {Ξ± : Type ?u.129338} β†’ {Ξ² : Type ?u.129337} β†’ (Ξ± β†’ Ξ² β†’ Ξ±) β†’ Ξ± β†’ List Ξ² β†’ Ξ±
foldl 
addLsb: β„• β†’ Bool β†’ β„•
addLsb 
k: β„•
k = 
2: ?m.129363
2 ^ 
x: List Bool
x.
length: {Ξ± : Type ?u.129372} β†’ List Ξ± β†’ β„•
length * 
k: β„•
k + 
x: List Bool
x.
foldl: {Ξ± : Type ?u.129377} β†’ {Ξ² : Type ?u.129376} β†’ (Ξ± β†’ Ξ² β†’ Ξ±) β†’ Ξ± β†’ List Ξ² β†’ Ξ±
foldl 
addLsb: β„• β†’ Bool β†’ β„•
addLsb 
0: ?m.129392
0 := 
Goals accomplished! πŸ™
x: List Bool

k: β„•

List.foldl addLsb k x = 2 ^ List.length x * k + List.foldl addLsb 0 x
x: List Bool

k: β„•

List.foldl addLsb k x = 2 ^ List.length x * k + List.foldl addLsb 0 x
x: List Bool

k: β„•

List.foldl addLsb k x = List.foldl addLsb (0 + k) x
x: List Bool

k: β„•

List.foldl addLsb k x = 2 ^ List.length x * k + List.foldl addLsb 0 x
x: List Bool

k: β„•

List.foldl addLsb k x = List.foldl addLsb k x
Goals accomplished! πŸ™


theorem 
foldl_addLsb_cons_zero: βˆ€ (a : Bool) (x : List Bool),
  List.foldl addLsb 0 (a :: x) = (2 ^ List.length x * bif a then 1 else 0) + List.foldl addLsb 0 x
foldl_addLsb_cons_zero (
a: Bool
a : 
Bool: Type
Bool) (
x: List Bool
x : 
List: Type ?u.129684 β†’ Type ?u.129684
List 
Bool: Type
Bool) :
    (
a: Bool
a::
x: List Bool
x).
foldl: {Ξ± : Type ?u.129692} β†’ {Ξ² : Type ?u.129691} β†’ (Ξ± β†’ Ξ² β†’ Ξ±) β†’ Ξ± β†’ List Ξ² β†’ Ξ±
foldl 
addLsb: β„• β†’ Bool β†’ β„•
addLsb 
0: ?m.129707
0 = 
2: ?m.129727
2^
x: List Bool
x.
length: {Ξ± : Type ?u.129736} β†’ List Ξ± β†’ β„•
length * 
cond: {Ξ± : Type ?u.129740} β†’ Bool β†’ Ξ± β†’ Ξ± β†’ Ξ±
cond 
a: Bool
a 
1: ?m.129743
1 
0: ?m.129753
0 + 
x: List Bool
x.
foldl: {Ξ± : Type ?u.129761} β†’ {Ξ² : Type ?u.129760} β†’ (Ξ± β†’ Ξ² β†’ Ξ±) β†’ Ξ± β†’ List Ξ² β†’ Ξ±
foldl 
addLsb: β„• β†’ Bool β†’ β„•
addLsb 
0: ?m.129776
0 :=
  calc (
a: Bool
a::
x: List Bool
x).
foldl: {Ξ± : Type ?u.129929} β†’ {Ξ² : Type ?u.129928} β†’ (Ξ± β†’ Ξ² β†’ Ξ±) β†’ Ξ± β†’ List Ξ² β†’ Ξ±
foldl 
addLsb: β„• β†’ Bool β†’ β„•
addLsb 
0: ?m.129944
0
     = 
x: List Bool
x.
foldl: {Ξ± : Type ?u.129947} β†’ {Ξ² : Type ?u.129946} β†’ (Ξ± β†’ Ξ² β†’ Ξ±) β†’ Ξ± β†’ List Ξ² β†’ Ξ±
foldl 
addLsb: β„• β†’ Bool β†’ β„•
addLsb (
0: ?m.129968
0 + 
0: ?m.129979
0 + 
cond: {Ξ± : Type ?u.129989} β†’ Bool β†’ Ξ± β†’ Ξ± β†’ Ξ±
cond 
a: Bool
a 
1: ?m.129992
1 
0: ?m.130002
0) := 
rfl: βˆ€ {Ξ± : Sort ?u.130072} {a : Ξ±}, a = a
rfl
   
_: ?m✝
_ = 
_: ?m.130127
_ := 
Goals accomplished! πŸ™
a: Bool

x: List Bool

List.foldl addLsb (0 + 0 + bif a then 1 else 0) x = (2 ^ List.length x * bif a then 1 else 0) + List.foldl addLsb 0 x
a: Bool

x: List Bool

List.foldl addLsb (0 + 0 + bif a then 1 else 0) x = (2 ^ List.length x * bif a then 1 else 0) + List.foldl addLsb 0 x
a: Bool

x: List Bool

(2 ^ List.length x * bif a then 1 else 0) + List.foldl addLsb (0 + 0) x =   (2 ^ List.length x * bif a then 1 else 0) + List.foldl addLsb 0 x
Goals accomplished! πŸ™


theorem 
toNat_adc_aux: βˆ€ {x y : List Bool},
  List.length x = List.length y β†’
    List.foldl addLsb (addLsb 0 (List.mapAccumrβ‚‚ (fun x y c => (Bitvec.carry x y c, Bitvec.xor3 x y c)) x y false).fst)
        (List.mapAccumrβ‚‚ (fun x y c => (Bitvec.carry x y c, Bitvec.xor3 x y c)) x y false).snd =       List.foldl addLsb 0 x + List.foldl addLsb 0 y
toNat_adc_aux : βˆ€ {
x: List Bool
x 
y: List Bool
y: 
List: Type ?u.130236 β†’ Type ?u.130236
List 
Bool: Type
Bool} (
_h: List.length x = List.length y
_h : 
List.length: {Ξ± : Type ?u.130240} β†’ List Ξ± β†’ β„•
List.length 
x: List Bool
x = 
List.length: {Ξ± : Type ?u.130244} β†’ List Ξ± β†’ β„•
List.length 
y: List Bool
y),
    
List.foldl: {Ξ± : Type ?u.130252} β†’ {Ξ² : Type ?u.130251} β†’ (Ξ± β†’ Ξ² β†’ Ξ±) β†’ Ξ± β†’ List Ξ² β†’ Ξ±
List.foldl 
addLsb: β„• β†’ Bool β†’ β„•
addLsb (
addLsb: β„• β†’ Bool β†’ β„•
addLsb 
0: ?m.130262
0 (
List.mapAccumrβ‚‚: {Ο† : Type ?u.130275} β†’
  {Οƒ : Type ?u.130274} β†’
    {Ξ± : Type ?u.130273} β†’ {Ξ² : Type ?u.130272} β†’ (Ξ± β†’ Ξ² β†’ Οƒ β†’ Οƒ Γ— Ο†) β†’ List Ξ± β†’ List Ξ² β†’ Οƒ β†’ Οƒ Γ— List Ο†
List.mapAccumrβ‚‚ (fun 
x: ?m.130281
x 
y: ?m.130284
y 
c: ?m.130287
c => (
Bitvec.carry: Bool β†’ Bool β†’ Bool β†’ Bool
Bitvec.carry 
x: ?m.130281
x 
y: ?m.130284
y 
c: ?m.130287
c, 
Bitvec.xor3: Bool β†’ Bool β†’ Bool β†’ Bool
Bitvec.xor3 
x: ?m.130281
x 
y: ?m.130284
y 
c: ?m.130287
c)) 
x: List Bool
x 
y: List Bool
y 
false: Bool
false).
fst: {Ξ± : Type ?u.130306} β†’ {Ξ² : Type ?u.130305} β†’ Ξ± Γ— Ξ² β†’ Ξ±
fst)
      (
List.mapAccumrβ‚‚: {Ο† : Type ?u.130312} β†’
  {Οƒ : Type ?u.130311} β†’
    {Ξ± : Type ?u.130310} β†’ {Ξ² : Type ?u.130309} β†’ (Ξ± β†’ Ξ² β†’ Οƒ β†’ Οƒ Γ— Ο†) β†’ List Ξ± β†’ List Ξ² β†’ Οƒ β†’ Οƒ Γ— List Ο†
List.mapAccumrβ‚‚ (fun 
x: ?m.130318
x 
y: ?m.130321
y 
c: ?m.130324
c => (
Bitvec.carry: Bool β†’ Bool β†’ Bool β†’ Bool
Bitvec.carry 
x: ?m.130318
x 
y: ?m.130321
y 
c: ?m.130324
c, 
Bitvec.xor3: Bool β†’ Bool β†’ Bool β†’ Bool
Bitvec.xor3 
x: ?m.130318
x 
y: ?m.130321
y 
c: ?m.130324
c)) 
x: List Bool
x 
y: List Bool
y 
false: Bool
false).
snd: {Ξ± : Type ?u.130341} β†’ {Ξ² : Type ?u.130340} β†’ Ξ± Γ— Ξ² β†’ Ξ²
snd =
    
List.foldl: {Ξ± : Type ?u.130348} β†’ {Ξ² : Type ?u.130347} β†’ (Ξ± β†’ Ξ² β†’ Ξ±) β†’ Ξ± β†’ List Ξ² β†’ Ξ±
List.foldl 
addLsb: β„• β†’ Bool β†’ β„•
addLsb 
0: ?m.130358
0 
x: List Bool
x + 
List.foldl: {Ξ± : Type ?u.130361} β†’ {Ξ² : Type ?u.130360} β†’ (Ξ± β†’ Ξ² β†’ Ξ±) β†’ Ξ± β†’ List Ξ² β†’ Ξ±
List.foldl 
addLsb: β„• β†’ Bool β†’ β„•
addLsb 
0: ?m.130371
0 
y: List Bool
y 
| [], [], _ => 
rfl: βˆ€ {Ξ± : Sort ?u.130456} {a : Ξ±}, a = a
rfl
| 
a: Bool
a::
x: List Bool
x, 
b: Bool
b::
y: List Bool
y, 
h: List.length (a :: x) = List.length (b :: y)
h => 
Goals accomplished! πŸ™
a: Bool

x: List Bool

b: Bool

y: List Bool

h: List.length (a :: x) = List.length (b :: y)

List.foldl addLsb
    (addLsb 0 (List.mapAccumrβ‚‚ (fun x y c => (Bitvec.carry x y c, Bitvec.xor3 x y c)) (a :: x) (b :: y) false).fst)
    (List.mapAccumrβ‚‚ (fun x y c => (Bitvec.carry x y c, Bitvec.xor3 x y c)) (a :: x) (b :: y) false).snd =   List.foldl addLsb 0 (a :: x) + List.foldl addLsb 0 (b :: y)
a: Bool

x: List Bool

b: Bool

y: List Bool

h: List.length x = List.length y

List.foldl addLsb
    (addLsb 0 (List.mapAccumrβ‚‚ (fun x y c => (Bitvec.carry x y c, Bitvec.xor3 x y c)) (a :: x) (b :: y) false).fst)
    (List.mapAccumrβ‚‚ (fun x y c => (Bitvec.carry x y c, Bitvec.xor3 x y c)) (a :: x) (b :: y) false).snd =   List.foldl addLsb 0 (a :: x) + List.foldl addLsb 0 (b :: y)
a: Bool

x: List Bool

b: Bool

y: List Bool

h: List.length (a :: x) = List.length (b :: y)

List.foldl addLsb
    (addLsb 0 (List.mapAccumrβ‚‚ (fun x y c => (Bitvec.carry x y c, Bitvec.xor3 x y c)) (a :: x) (b :: y) false).fst)
    (List.mapAccumrβ‚‚ (fun x y c => (Bitvec.carry x y c, Bitvec.xor3 x y c)) (a :: x) (b :: y) false).snd =   List.foldl addLsb 0 (a :: x) + List.foldl addLsb 0 (b :: y)
a: Bool

x: List Bool

b: Bool

y: List Bool

h: List.length x = List.length y

List.foldl addLsb
    (addLsb 0 (List.mapAccumrβ‚‚ (fun x y c => (Bitvec.carry x y c, Bitvec.xor3 x y c)) (a :: x) (b :: y) false).fst)
    (List.mapAccumrβ‚‚ (fun x y c => (Bitvec.carry x y c, Bitvec.xor3 x y c)) (a :: x) (b :: y) false).snd =   List.foldl addLsb 0 (a :: x) + List.foldl addLsb 0 (b :: y)
a: Bool

x: List Bool

b: Bool

y: List Bool

h: List.length x = List.length y

List.foldl addLsb
    (addLsb 0 (List.mapAccumrβ‚‚ (fun x y c => (Bitvec.carry x y c, Bitvec.xor3 x y c)) (a :: x) (b :: y) false).fst)
    (List.mapAccumrβ‚‚ (fun x y c => (Bitvec.carry x y c, Bitvec.xor3 x y c)) (a :: x) (b :: y) false).snd =   (2 ^ List.length x * bif a then 1 else 0) + List.foldl addLsb 0 x + List.foldl addLsb 0 (b :: y)
a: Bool

x: List Bool

b: Bool

y: List Bool

h: List.length x = List.length y

List.foldl addLsb
    (addLsb 0 (List.mapAccumrβ‚‚ (fun x y c => (Bitvec.carry x y c, Bitvec.xor3 x y c)) (a :: x) (b :: y) false).fst)
    (List.mapAccumrβ‚‚ (fun x y c => (Bitvec.carry x y c, Bitvec.xor3 x y c)) (a :: x) (b :: y) false).snd =   List.foldl addLsb 0 (a :: x) + List.foldl addLsb 0 (b :: y)
a: Bool

x: List Bool

b: Bool

y: List Bool

h: List.length x = List.length y

List.foldl addLsb
    (addLsb 0 (List.mapAccumrβ‚‚ (fun x y c => (Bitvec.carry x y c, Bitvec.xor3 x y c)) (a :: x) (b :: y) false).fst)
    (List.mapAccumrβ‚‚ (fun x y c => (Bitvec.carry x y c, Bitvec.xor3 x y c)) (a :: x) (b :: y) false).snd =   (2 ^ List.length x * bif a then 1 else 0) + List.foldl addLsb 0 x +     ((2 ^ List.length y * bif b then 1 else 0) + List.foldl addLsb 0 y)
a: Bool

x: List Bool

b: Bool

y: List Bool

h: List.length x = List.length y

List.foldl addLsb
    (addLsb 0 (List.mapAccumrβ‚‚ (fun x y c => (Bitvec.carry x y c, Bitvec.xor3 x y c)) (a :: x) (b :: y) false).fst)
    (List.mapAccumrβ‚‚ (fun x y c => (Bitvec.carry x y c, Bitvec.xor3 x y c)) (a :: x) (b :: y) false).snd =   List.foldl addLsb 0 (a :: x) + List.foldl addLsb 0 (b :: y)
a: Bool

x: List Bool

b: Bool

y: List Bool

h: List.length x = List.length y

List.foldl addLsb
    (addLsb 0 (List.mapAccumrβ‚‚ (fun x y c => (Bitvec.carry x y c, Bitvec.xor3 x y c)) (a :: x) (b :: y) false).fst)
    (List.mapAccumrβ‚‚ (fun x y c => (Bitvec.carry x y c, Bitvec.xor3 x y c)) (a :: x) (b :: y) false).snd =   ((2 ^ List.length x * bif a then 1 else 0) + 2 ^ List.length y * bif b then 1 else 0) +     (List.foldl addLsb 0 x + List.foldl addLsb 0 y)
a: Bool

x: List Bool

b: Bool

y: List Bool

h: List.length x = List.length y

List.foldl addLsb
    (addLsb 0 (List.mapAccumrβ‚‚ (fun x y c => (Bitvec.carry x y c, Bitvec.xor3 x y c)) (a :: x) (b :: y) false).fst)
    (List.mapAccumrβ‚‚ (fun x y c => (Bitvec.carry x y c, Bitvec.xor3 x y c)) (a :: x) (b :: y) false).snd =   List.foldl addLsb 0 (a :: x) + List.foldl addLsb 0 (b :: y)
a: Bool

x: List Bool

b: Bool

y: List Bool

h: List.length x = List.length y

List.foldl addLsb
    (addLsb 0 (List.mapAccumrβ‚‚ (fun x y c => (Bitvec.carry x y c, Bitvec.xor3 x y c)) (a :: x) (b :: y) false).fst)
    (List.mapAccumrβ‚‚ (fun x y c => (Bitvec.carry x y c, Bitvec.xor3 x y c)) (a :: x) (b :: y) false).snd =   ((2 ^ List.length x * bif a then 1 else 0) + 2 ^ List.length y * bif b then 1 else 0) +     List.foldl addLsb (addLsb 0 (List.mapAccumrβ‚‚ (fun x y c => (Bitvec.carry x y c, Bitvec.xor3 x y c)) x y false).fst)
      (List.mapAccumrβ‚‚ (fun x y c => (Bitvec.carry x y c, Bitvec.xor3 x y c)) x y false).snd
a: Bool

x: List Bool

b: Bool

y: List Bool

h: List.length x = List.length y

List.foldl addLsb
    (addLsb 0 (List.mapAccumrβ‚‚ (fun x y c => (Bitvec.carry x y c, Bitvec.xor3 x y c)) (a :: x) (b :: y) false).fst)
    (List.mapAccumrβ‚‚ (fun x y c => (Bitvec.carry x y c, Bitvec.xor3 x y c)) (a :: x) (b :: y) false).snd =   List.foldl addLsb 0 (a :: x) + List.foldl addLsb 0 (b :: y)
a: Bool

x: List Bool

b: Bool

y: List Bool

h: List.length x = List.length y

List.foldl addLsb
    (addLsb 0
      (let r := List.mapAccumrβ‚‚ (fun x y c => (Bitvec.carry x y c, Bitvec.xor3 x y c)) x y false;
        let q := (Bitvec.carry a b r.fst, Bitvec.xor3 a b r.fst);
        (q.fst, q.snd :: r.snd)).fst)
    (let r := List.mapAccumrβ‚‚ (fun x y c => (Bitvec.carry x y c, Bitvec.xor3 x y c)) x y false;
      let q := (Bitvec.carry a b r.fst, Bitvec.xor3 a b r.fst);
      (q.fst, q.snd :: r.snd)).snd =   ((2 ^ List.length x * bif a then 1 else 0) + 2 ^ List.length y * bif b then 1 else 0) +     List.foldl addLsb (addLsb 0 (List.mapAccumrβ‚‚ (fun x y c => (Bitvec.carry x y c, Bitvec.xor3 x y c)) x y false).fst)
      (List.mapAccumrβ‚‚ (fun x y c => (Bitvec.carry x y c, Bitvec.xor3 x y c)) x y false).snd
a: Bool

x: List Bool

b: Bool

y: List Bool

h: List.length x = List.length y

List.foldl addLsb
    (addLsb 0
      (let r := List.mapAccumrβ‚‚ (fun x y c => (Bitvec.carry x y c, Bitvec.xor3 x y c)) x y false;
        let q := (Bitvec.carry a b r.fst, Bitvec.xor3 a b r.fst);
        (q.fst, q.snd :: r.snd)).fst)
    (let r := List.mapAccumrβ‚‚ (fun x y c => (Bitvec.carry x y c, Bitvec.xor3 x y c)) x y false;
      let q := (Bitvec.carry a b r.fst, Bitvec.xor3 a b r.fst);
      (q.fst, q.snd :: r.snd)).snd =   ((2 ^ List.length x * bif a then 1 else 0) + 2 ^ List.length y * bif b then 1 else 0) +     List.foldl addLsb (addLsb 0 (List.mapAccumrβ‚‚ (fun x y c => (Bitvec.carry x y c, Bitvec.xor3 x y c)) x y false).fst)
      (List.mapAccumrβ‚‚ (fun x y c => (Bitvec.carry x y c, Bitvec.xor3 x y c)) x y false).snd
a: Bool

x: List Bool

b: Bool

y: List Bool

h: List.length (a :: x) = List.length (b :: y)

List.foldl addLsb
    (addLsb 0 (List.mapAccumrβ‚‚ (fun x y c => (Bitvec.carry x y c, Bitvec.xor3 x y c)) (a :: x) (b :: y) false).fst)
    (List.mapAccumrβ‚‚ (fun x y c => (Bitvec.carry x y c, Bitvec.xor3 x y c)) (a :: x) (b :: y) false).snd =   List.foldl addLsb 0 (a :: x) + List.foldl addLsb 0 (b :: y)
a: Bool

x: List Bool

b: Bool

y: List Bool

h: List.length x = List.length y

List.foldl addLsb
    (addLsb 0
      (a && b || a && (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).fst ||         b && (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).fst))
    (xor (xor a b) (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).fst ::       (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).snd) =   ((2 ^ List.length x * bif a then 1 else 0) + 2 ^ List.length y * bif b then 1 else 0) +     List.foldl addLsb
      (addLsb 0 (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).fst)
      (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).snd
a: Bool

x: List Bool

b: Bool

y: List Bool

h: List.length (a :: x) = List.length (b :: y)

List.foldl addLsb
    (addLsb 0 (List.mapAccumrβ‚‚ (fun x y c => (Bitvec.carry x y c, Bitvec.xor3 x y c)) (a :: x) (b :: y) false).fst)
    (List.mapAccumrβ‚‚ (fun x y c => (Bitvec.carry x y c, Bitvec.xor3 x y c)) (a :: x) (b :: y) false).snd =   List.foldl addLsb 0 (a :: x) + List.foldl addLsb 0 (b :: y)
a: Bool

x: List Bool

b: Bool

y: List Bool

h: List.length x = List.length y

List.foldl addLsb
    (addLsb 0
      (a && b || a && (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).fst ||         b && (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).fst))
    (xor (xor a b) (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).fst ::       (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).snd) =   ((2 ^ List.length x * bif a then 1 else 0) + 2 ^ List.length y * bif b then 1 else 0) +     List.foldl addLsb
      (addLsb 0 (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).fst)
      (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).snd
a: Bool

x: List Bool

b: Bool

y: List Bool

h: List.length x = List.length y

2 ^         List.length
          (xor (xor a b) (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).fst ::             (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).snd) *       addLsb 0
        (a && b || a && (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).fst ||           b && (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).fst) +     List.foldl addLsb 0
      (xor (xor a b) (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).fst ::         (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).snd) =   ((2 ^ List.length x * bif a then 1 else 0) + 2 ^ List.length y * bif b then 1 else 0) +     List.foldl addLsb
      (addLsb 0 (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).fst)
      (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).snd
a: Bool

x: List Bool

b: Bool

y: List Bool

h: List.length x = List.length y

List.foldl addLsb
    (addLsb 0
      (a && b || a && (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).fst ||         b && (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).fst))
    (xor (xor a b) (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).fst ::       (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).snd) =   ((2 ^ List.length x * bif a then 1 else 0) + 2 ^ List.length y * bif b then 1 else 0) +     List.foldl addLsb
      (addLsb 0 (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).fst)
      (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).snd
a: Bool

x: List Bool

b: Bool

y: List Bool

h: List.length x = List.length y

2 ^         List.length
          (xor (xor a b) (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).fst ::             (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).snd) *       addLsb 0
        (a && b || a && (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).fst ||           b && (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).fst) +     ((2 ^ List.length (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).snd *         bif
            xor (xor a b)
              (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).fst then
          1
        else 0) +       List.foldl addLsb 0
        (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).snd) =   ((2 ^ List.length x * bif a then 1 else 0) + 2 ^ List.length y * bif b then 1 else 0) +     List.foldl addLsb
      (addLsb 0 (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).fst)
      (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).snd
a: Bool

x: List Bool

b: Bool

y: List Bool

h: List.length x = List.length y

List.foldl addLsb
    (addLsb 0
      (a && b || a && (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).fst ||         b && (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).fst))
    (xor (xor a b) (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).fst ::       (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).snd) =   ((2 ^ List.length x * bif a then 1 else 0) + 2 ^ List.length y * bif b then 1 else 0) +     List.foldl addLsb
      (addLsb 0 (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).fst)
      (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).snd
a: Bool

x: List Bool

b: Bool

y: List Bool

h: List.length x = List.length y

2 ^         List.length
          (xor (xor a b) (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).fst ::             (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).snd) *       addLsb 0
        (a && b || a && (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).fst ||           b && (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).fst) +     ((2 ^ List.length (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).snd *         bif
            xor (xor a b)
              (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).fst then
          1
        else 0) +       List.foldl addLsb 0
        (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).snd) =   ((2 ^ List.length x * bif a then 1 else 0) + 2 ^ List.length y * bif b then 1 else 0) +     (2 ^ List.length (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).snd *         addLsb 0 (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).fst +       List.foldl addLsb 0 (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).snd)
a: Bool

x: List Bool

b: Bool

y: List Bool

h: List.length x = List.length y

2 ^         List.length
          (xor (xor a b) (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).fst ::             (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).snd) *       addLsb 0
        (a && b || a && (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).fst ||           b && (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).fst) +     ((2 ^ List.length (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).snd *         bif
            xor (xor a b)
              (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).fst then
          1
        else 0) +       List.foldl addLsb 0
        (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).snd) =   ((2 ^ List.length x * bif a then 1 else 0) + 2 ^ List.length y * bif b then 1 else 0) +     (2 ^ List.length (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).snd *         addLsb 0 (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).fst +       List.foldl addLsb 0 (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).snd)
a: Bool

x: List Bool

b: Bool

y: List Bool

h: List.length (a :: x) = List.length (b :: y)

List.foldl addLsb
    (addLsb 0 (List.mapAccumrβ‚‚ (fun x y c => (Bitvec.carry x y c, Bitvec.xor3 x y c)) (a :: x) (b :: y) false).fst)
    (List.mapAccumrβ‚‚ (fun x y c => (Bitvec.carry x y c, Bitvec.xor3 x y c)) (a :: x) (b :: y) false).snd =   List.foldl addLsb 0 (a :: x) + List.foldl addLsb 0 (b :: y)
x: List Bool

b: Bool

y: List Bool

h: List.length x = List.length y

false
2 ^         List.length
          (xor (xor false b)
              (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).fst ::             (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).snd) *       addLsb 0
        (false && b ||             false && (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).fst ||           b && (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).fst) +     ((2 ^ List.length (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).snd *         bif
            xor (xor false b)
              (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).fst then
          1
        else 0) +       List.foldl addLsb 0
        (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).snd) =   ((2 ^ List.length x * bif false then 1 else 0) + 2 ^ List.length y * bif b then 1 else 0) +     (2 ^ List.length (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).snd *         addLsb 0 (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).fst +       List.foldl addLsb 0 (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).snd)
x: List Bool

b: Bool

y: List Bool

h: List.length x = List.length y

true
2 ^         List.length
          (xor (xor true b)
              (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).fst ::             (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).snd) *       addLsb 0
        (true && b ||             true && (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).fst ||           b && (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).fst) +     ((2 ^ List.length (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).snd *         bif
            xor (xor true b)
              (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).fst then
          1
        else 0) +       List.foldl addLsb 0
        (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).snd) =   ((2 ^ List.length x * bif true then 1 else 0) + 2 ^ List.length y * bif b then 1 else 0) +     (2 ^ List.length (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).snd *         addLsb 0 (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).fst +       List.foldl addLsb 0 (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).snd)
a: Bool

x: List Bool

b: Bool

y: List Bool

h: List.length x = List.length y

2 ^         List.length
          (xor (xor a b) (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).fst ::             (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).snd) *       addLsb 0
        (a && b || a && (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).fst ||           b && (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).fst) +     ((2 ^ List.length (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).snd *         bif
            xor (xor a b)
              (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).fst then
          1
        else 0) +       List.foldl addLsb 0
        (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).snd) =   ((2 ^ List.length x * bif a then 1 else 0) + 2 ^ List.length y * bif b then 1 else 0) +     (2 ^ List.length (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).snd *         addLsb 0 (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).fst +       List.foldl addLsb 0 (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).snd)
x: List Bool

b: Bool

y: List Bool

h: List.length x = List.length y

false
2 ^         List.length
          (xor (xor false b)
              (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).fst ::             (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).snd) *       addLsb 0
        (false && b ||             false && (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).fst ||           b && (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).fst) +     ((2 ^ List.length (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).snd *         bif
            xor (xor false b)
              (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).fst then
          1
        else 0) +       List.foldl addLsb 0
        (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).snd) =   ((2 ^ List.length x * bif false then 1 else 0) + 2 ^ List.length y * bif b then 1 else 0) +     (2 ^ List.length (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).snd *         addLsb 0 (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).fst +       List.foldl addLsb 0 (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).snd)
x: List Bool

b: Bool

y: List Bool

h: List.length x = List.length y

true
2 ^         List.length
          (xor (xor true b)
              (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).fst ::             (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).snd) *       addLsb 0
        (true && b ||             true && (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).fst ||           b && (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).fst) +     ((2 ^ List.length (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).snd *         bif
            xor (xor true b)
              (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).fst then
          1
        else 0) +       List.foldl addLsb 0
        (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).snd) =   ((2 ^ List.length x * bif true then 1 else 0) + 2 ^ List.length y * bif b then 1 else 0) +     (2 ^ List.length (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).snd *         addLsb 0 (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).fst +       List.foldl addLsb 0 (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).snd)
a: Bool

x: List Bool

b: Bool

y: List Bool

h: List.length x = List.length y

2 ^         List.length
          (xor (xor a b) (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).fst ::             (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).snd) *       addLsb 0
        (a && b || a && (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).fst ||           b && (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).fst) +     ((2 ^ List.length (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).snd *         bif
            xor (xor a b)
              (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).fst then
          1
        else 0) +       List.foldl addLsb 0
        (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).snd) =   ((2 ^ List.length x * bif a then 1 else 0) + 2 ^ List.length y * bif b then 1 else 0) +     (2 ^ List.length (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).snd *         addLsb 0 (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).fst +       List.foldl addLsb 0 (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).snd)
x, y: List Bool

h: List.length x = List.length y

true.false
2 ^         List.length
          (xor (xor true false)
              (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).fst ::             (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).snd) *       addLsb 0
        (true && false ||             true && (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).fst ||           false && (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).fst) +     ((2 ^ List.length (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).snd *         bif
            xor (xor true false)
              (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).fst then
          1
        else 0) +       List.foldl addLsb 0
        (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).snd) =   ((2 ^ List.length x * bif true then 1 else 0) + 2 ^ List.length y * bif false then 1 else 0) +     (2 ^ List.length (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).snd *         addLsb 0 (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).fst +       List.foldl addLsb 0 (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).snd)
x, y: List Bool

h: List.length x = List.length y

true.true
2 ^         List.length
          (xor (xor true true)
              (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).fst ::             (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).snd) *       addLsb 0
        (true && true ||             true && (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).fst ||           true && (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).fst) +     ((2 ^ List.length (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).snd *         bif
            xor (xor true true)
              (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).fst then
          1
        else 0) +       List.foldl addLsb 0
        (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).snd) =   ((2 ^ List.length x * bif true then 1 else 0) + 2 ^ List.length y * bif true then 1 else 0) +     (2 ^ List.length (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).snd *         addLsb 0 (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).fst +       List.foldl addLsb 0 (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).snd)
a: Bool

x: List Bool

b: Bool

y: List Bool

h: List.length x = List.length y

2 ^         List.length
          (xor (xor a b) (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).fst ::             (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).snd) *       addLsb 0
        (a && b || a && (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).fst ||           b && (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).fst) +     ((2 ^ List.length (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).snd *         bif
            xor (xor a b)
              (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).fst then
          1
        else 0) +       List.foldl addLsb 0
        (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).snd) =   ((2 ^ List.length x * bif a then 1 else 0) + 2 ^ List.length y * bif b then 1 else 0) +     (2 ^ List.length (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).snd *         addLsb 0 (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).fst +       List.foldl addLsb 0 (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).snd)
x, y: List Bool

h: List.length x = List.length y

false.false
2 ^         List.length
          (xor (xor false false)
              (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).fst ::             (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).snd) *       addLsb 0
        (false && false ||             false && (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).fst ||           false && (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).fst) +     ((2 ^ List.length (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).snd *         bif
            xor (xor false false)
              (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).fst then
          1
        else 0) +       List.foldl addLsb 0
        (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).snd) =   ((2 ^ List.length x * bif false then 1 else 0) + 2 ^ List.length y * bif false then 1 else 0) +     (2 ^ List.length (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).snd *         addLsb 0 (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).fst +       List.foldl addLsb 0 (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).snd)
x, y: List Bool

h: List.length x = List.length y

false.true
2 ^         List.length
          (xor (xor false true)
              (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).fst ::             (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).snd) *       addLsb 0
        (false && true ||             false && (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).fst ||           true && (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).fst) +     ((2 ^ List.length (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).snd *         bif
            xor (xor false true)
              (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).fst then
          1
        else 0) +       List.foldl addLsb 0
        (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).snd) =   ((2 ^ List.length x * bif false then 1 else 0) + 2 ^ List.length y * bif true then 1 else 0) +     (2 ^ List.length (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).snd *         addLsb 0 (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).fst +       List.foldl addLsb 0 (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).snd)
x, y: List Bool

h: List.length x = List.length y

true.false
2 ^         List.length
          (xor (xor true false)
              (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).fst ::             (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).snd) *       addLsb 0
        (true && false ||             true && (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).fst ||           false && (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).fst) +     ((2 ^ List.length (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).snd *         bif
            xor (xor true false)
              (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).fst then
          1
        else 0) +       List.foldl addLsb 0
        (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).snd) =   ((2 ^ List.length x * bif true then 1 else 0) + 2 ^ List.length y * bif false then 1 else 0) +     (2 ^ List.length (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).snd *         addLsb 0 (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).fst +       List.foldl addLsb 0 (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).snd)
x, y: List Bool

h: List.length x = List.length y

true.true
2 ^         List.length
          (xor (xor true true)
              (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).fst ::             (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).snd) *       addLsb 0
        (true && true ||             true && (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).fst ||           true && (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).fst) +     ((2 ^ List.length (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).snd *         bif
            xor (xor true true)
              (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).fst then
          1
        else 0) +       List.foldl addLsb 0
        (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).snd) =   ((2 ^ List.length x * bif true then 1 else 0) + 2 ^ List.length y * bif true then 1 else 0) +     (2 ^ List.length (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).snd *         addLsb 0 (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).fst +       List.foldl addLsb 0 (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).snd)
a: Bool

x: List Bool

b: Bool

y: List Bool

h: List.length x = List.length y

2 ^         List.length
          (xor (xor a b) (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).fst ::             (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).snd) *       addLsb 0
        (a && b || a && (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).fst ||           b && (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).fst) +     ((2 ^ List.length (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).snd *         bif
            xor (xor a b)
              (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).fst then
          1
        else 0) +       List.foldl addLsb 0
        (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).snd) =   ((2 ^ List.length x * bif a then 1 else 0) + 2 ^ List.length y * bif b then 1 else 0) +     (2 ^ List.length (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).snd *         addLsb 0 (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).fst +       List.foldl addLsb 0 (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).snd)
x, y: List Bool

h: List.length x = List.length y

false.true
(2 ^ List.length y *       bif (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor x (xor y c))) x y false).fst then 0 else 1) +     ((2 ^ List.length y *         bif (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor x (xor y c))) x y false).fst then 1
        else 0) +       ((2 ^ List.length y *           bif (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor x (xor y c))) x y false).fst then 1
          else 0) +         List.foldl addLsb 0
          (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor x (xor y c))) x y false).snd)) =   2 ^ List.length y +     ((2 ^ List.length y *         bif (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor x (xor y c))) x y false).fst then 1
        else 0) +       List.foldl addLsb 0 (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor x (xor y c))) x y false).snd)
a: Bool

x: List Bool

b: Bool

y: List Bool

h: List.length x = List.length y

2 ^         List.length
          (xor (xor a b) (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).fst ::             (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).snd) *       addLsb 0
        (a && b || a && (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).fst ||           b && (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).fst) +     ((2 ^ List.length (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).snd *         bif
            xor (xor a b)
              (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).fst then
          1
        else 0) +       List.foldl addLsb 0
        (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).snd) =   ((2 ^ List.length x * bif a then 1 else 0) + 2 ^ List.length y * bif b then 1 else 0) +     (2 ^ List.length (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).snd *         addLsb 0 (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).fst +       List.foldl addLsb 0 (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).snd)
x, y: List Bool

h: List.length x = List.length y

false.true
(2 ^ List.length y *       bif (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor x (xor y c))) x y false).fst then 0 else 1) +     ((2 ^ List.length y *         bif (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor x (xor y c))) x y false).fst then 1
        else 0) +       ((2 ^ List.length y *           bif (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor x (xor y c))) x y false).fst then 1
          else 0) +         List.foldl addLsb 0
          (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor x (xor y c))) x y false).snd)) =   2 ^ List.length y +     ((2 ^ List.length y *         bif (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor x (xor y c))) x y false).fst then 1
        else 0) +       List.foldl addLsb 0 (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor x (xor y c))) x y false).snd)
x, y: List Bool

h: List.length x = List.length y

true.false
(2 ^ List.length y *       bif (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor x (xor y c))) x y false).fst then 0 else 1) +     ((2 ^ List.length y *         bif (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor x (xor y c))) x y false).fst then 1
        else 0) +       ((2 ^ List.length y *           bif (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor x (xor y c))) x y false).fst then 1
          else 0) +         List.foldl addLsb 0
          (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor x (xor y c))) x y false).snd)) =   2 ^ List.length y +     ((2 ^ List.length y *         bif (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor x (xor y c))) x y false).fst then 1
        else 0) +       List.foldl addLsb 0 (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor x (xor y c))) x y false).snd)
a: Bool

x: List Bool

b: Bool

y: List Bool

h: List.length x = List.length y

2 ^         List.length
          (xor (xor a b) (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).fst ::             (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).snd) *       addLsb 0
        (a && b || a && (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).fst ||           b && (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).fst) +     ((2 ^ List.length (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).snd *         bif
            xor (xor a b)
              (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).fst then
          1
        else 0) +       List.foldl addLsb 0
        (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).snd) =   ((2 ^ List.length x * bif a then 1 else 0) + 2 ^ List.length y * bif b then 1 else 0) +     (2 ^ List.length (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).snd *         addLsb 0 (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).fst +       List.foldl addLsb 0 (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).snd)
x, y: List Bool

h: List.length x = List.length y

true.false.false
(2 ^ List.length y * bif false then 0 else 1) +     ((2 ^ List.length y * bif false then 1 else 0) +       ((2 ^ List.length y * bif false then 1 else 0) +         List.foldl addLsb 0
          (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor x (xor y c))) x y false).snd)) =   2 ^ List.length y +     ((2 ^ List.length y * bif false then 1 else 0) +       List.foldl addLsb 0 (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor x (xor y c))) x y false).snd)
x, y: List Bool

h: List.length x = List.length y

true.false.true
(2 ^ List.length y * bif true then 0 else 1) +     ((2 ^ List.length y * bif true then 1 else 0) +       ((2 ^ List.length y * bif true then 1 else 0) +         List.foldl addLsb 0
          (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor x (xor y c))) x y false).snd)) =   2 ^ List.length y +     ((2 ^ List.length y * bif true then 1 else 0) +       List.foldl addLsb 0 (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor x (xor y c))) x y false).snd)
a: Bool

x: List Bool

b: Bool

y: List Bool

h: List.length x = List.length y

2 ^         List.length
          (xor (xor a b) (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).fst ::             (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).snd) *       addLsb 0
        (a && b || a && (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).fst ||           b && (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).fst) +     ((2 ^ List.length (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).snd *         bif
            xor (xor a b)
              (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).fst then
          1
        else 0) +       List.foldl addLsb 0
        (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).snd) =   ((2 ^ List.length x * bif a then 1 else 0) + 2 ^ List.length y * bif b then 1 else 0) +     (2 ^ List.length (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).snd *         addLsb 0 (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).fst +       List.foldl addLsb 0 (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).snd)
x, y: List Bool

h: List.length x = List.length y

false.true.false
(2 ^ List.length y * bif false then 0 else 1) +     ((2 ^ List.length y * bif false then 1 else 0) +       ((2 ^ List.length y * bif false then 1 else 0) +         List.foldl addLsb 0
          (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor x (xor y c))) x y false).snd)) =   2 ^ List.length y +     ((2 ^ List.length y * bif false then 1 else 0) +       List.foldl addLsb 0 (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor x (xor y c))) x y false).snd)
x, y: List Bool

h: List.length x = List.length y

false.true.true
(2 ^ List.length y * bif true then 0 else 1) +     ((2 ^ List.length y * bif true then 1 else 0) +       ((2 ^ List.length y * bif true then 1 else 0) +         List.foldl addLsb 0
          (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor x (xor y c))) x y false).snd)) =   2 ^ List.length y +     ((2 ^ List.length y * bif true then 1 else 0) +       List.foldl addLsb 0 (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor x (xor y c))) x y false).snd)
x, y: List Bool

h: List.length x = List.length y

true.false.false
(2 ^ List.length y * bif false then 0 else 1) +     ((2 ^ List.length y * bif false then 1 else 0) +       ((2 ^ List.length y * bif false then 1 else 0) +         List.foldl addLsb 0
          (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor x (xor y c))) x y false).snd)) =   2 ^ List.length y +     ((2 ^ List.length y * bif false then 1 else 0) +       List.foldl addLsb 0 (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor x (xor y c))) x y false).snd)
x, y: List Bool

h: List.length x = List.length y

true.false.true
(2 ^ List.length y * bif true then 0 else 1) +     ((2 ^ List.length y * bif true then 1 else 0) +       ((2 ^ List.length y * bif true then 1 else 0) +         List.foldl addLsb 0
          (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor x (xor y c))) x y false).snd)) =   2 ^ List.length y +     ((2 ^ List.length y * bif true then 1 else 0) +       List.foldl addLsb 0 (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor x (xor y c))) x y false).snd)
a: Bool

x: List Bool

b: Bool

y: List Bool

h: List.length x = List.length y

2 ^         List.length
          (xor (xor a b) (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).fst ::             (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).snd) *       addLsb 0
        (a && b || a && (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).fst ||           b && (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).fst) +     ((2 ^ List.length (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).snd *         bif
            xor (xor a b)
              (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).fst then
          1
        else 0) +       List.foldl addLsb 0
        (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).snd) =   ((2 ^ List.length x * bif a then 1 else 0) + 2 ^ List.length y * bif b then 1 else 0) +     (2 ^ List.length (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).snd *         addLsb 0 (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).fst +       List.foldl addLsb 0 (List.mapAccumrβ‚‚ (fun x y c => (x && y || x && c || y && c, xor (xor x y) c)) x y false).snd)
Goals accomplished! πŸ™
  

theorem 
toNat_adc: βˆ€ {n : β„•} {x y : Bitvec n}, Bitvec.toNat (adc x y false) = Bitvec.toNat x + Bitvec.toNat y
toNat_adc {
n: β„•
n : 
Nat: Type
Nat} {
x: Bitvec n
x 
y: Bitvec n
y : 
Bitvec: β„• β†’ Type
Bitvec 
n: β„•
n} : (
Bitvec.adc: {n : β„•} β†’ Bitvec n β†’ Bitvec n β†’ Bool β†’ Bitvec (n + 1)
Bitvec.adc 
x: Bitvec n
x 
y: Bitvec n
y 
false: Bool
false).
toNat: {n : β„•} β†’ Bitvec n β†’ β„•
toNat = 
x: Bitvec n
x.
toNat: {n : β„•} β†’ Bitvec n β†’ β„•
toNat + 
y: Bitvec n
y.
toNat: {n : β„•} β†’ Bitvec n β†’ β„•
toNat := 
Goals accomplished! πŸ™
n: β„•

x, y: Bitvec n

Bitvec.toNat (adc x y false) = Bitvec.toNat x + Bitvec.toNat y
n: β„•

y: Bitvec n

x: List Bool

hx: List.length x = n

mk
Bitvec.toNat (adc { val := x, property := hx } y false) = Bitvec.toNat { val := x, property := hx } + Bitvec.toNat y
n: β„•

x, y: Bitvec n

Bitvec.toNat (adc x y false) = Bitvec.toNat x + Bitvec.toNat y
n: β„•

x: List Bool

hx: List.length x = n

y: List Bool

hy: List.length y = n

mk.mk
Bitvec.toNat (adc { val := x, property := hx } { val := y, property := hy } false) =   Bitvec.toNat { val := x, property := hx } + Bitvec.toNat { val := y, property := hy }
n: β„•

x, y: Bitvec n

Bitvec.toNat (adc x y false) = Bitvec.toNat x + Bitvec.toNat y
x, y: List Bool

hy: List.length y = List.length x

mk.mk
Bitvec.toNat (adc { val := x, property := (_ : List.length x = List.length x) } { val := y, property := hy } false) =   Bitvec.toNat { val := x, property := (_ : List.length x = List.length x) } + Bitvec.toNat { val := y, property := hy }
n: β„•

x, y: Bitvec n

Bitvec.toNat (adc x y false) = Bitvec.toNat x + Bitvec.toNat y
x, y: List Bool

hy: List.length y = List.length x

mk.mk
List.foldl addLsb (addLsb 0 (List.mapAccumrβ‚‚ (fun x y c => (Bitvec.carry x y c, Bitvec.xor3 x y c)) x y false).fst)
    (List.mapAccumrβ‚‚ (fun x y c => (Bitvec.carry x y c, Bitvec.xor3 x y c)) x y false).snd =   List.foldl addLsb 0 x + List.foldl addLsb 0 y
n: β„•

x, y: Bitvec n

Bitvec.toNat (adc x y false) = Bitvec.toNat x + Bitvec.toNat y
Goals accomplished! πŸ™


theorem 
toNat_tail: βˆ€ {n : β„•} (x : Bitvec n), Bitvec.toNat (Vector.tail x) = Bitvec.toNat x % 2 ^ (n - 1)
toNat_tail : βˆ€ {
n: β„•
n : 
Nat: Type
Nat} (
x: Bitvec n
x : 
Bitvec: β„• β†’ Type
Bitvec 
n: β„•
n), 
Bitvec.toNat: {n : β„•} β†’ Bitvec n β†’ β„•
Bitvec.toNat 
x: Bitvec n
x.
tail: {Ξ± : Type ?u.143473} β†’ {n : β„•} β†’ Vector Ξ± n β†’ Vector Ξ± (n - 1)
tail = 
x: Bitvec n
x.
toNat: {n : β„•} β†’ Bitvec n β†’ β„•
toNat % 
2: ?m.143492
2^(
n: β„•
n-
1: ?m.143505
1)
  | 
0: β„•
0, ⟨[], _⟩ => 
rfl: βˆ€ {Ξ± : Sort ?u.143701} {a : Ξ±}, a = a
rfl
  | 
n: β„•
n+
1: β„•
1, ⟨
a: Bool
a::
l: List Bool
l, 
h: List.length (a :: l) = n + 1
h⟩ => 
Goals accomplished! πŸ™
n: β„•

a: Bool

l: List Bool

h: List.length (a :: l) = n + 1

Bitvec.toNat (Vector.tail { val := a :: l, property := h }) =   Bitvec.toNat { val := a :: l, property := h } % 2 ^ (n + 1 - 1)
n: β„•

a: Bool

l: List Bool

h: List.length (a :: l) = n + 1

Bitvec.toNat (Vector.tail { val := a :: l, property := h }) =   Bitvec.toNat { val := a :: l, property := h } % 2 ^ (n + 1 - 1)
n: β„•

a: Bool

l: List Bool

h: List.length (a :: l) = n + 1

Bitvec.toNat (Vector.tail { val := a :: l, property := h })
n: β„•

a: Bool

l: List Bool

h: List.length (a :: l) = n + 1

Bitvec.toNat (Vector.tail { val := a :: l, property := h }) % 2 ^ (n + 1 - 1)
n: β„•

a: Bool

l: List Bool

h: List.length (a :: l) = n + 1

Bitvec.toNat (Vector.tail { val := a :: l, property := h }) % 2 ^ (n + 1 - 1)
n: β„•

a: Bool

l: List Bool

h: List.length (a :: l) = n + 1

Bitvec.toNat (Vector.tail { val := a :: l, property := h }) =   Bitvec.toNat { val := a :: l, property := h } % 2 ^ (n + 1 - 1)
n: β„•

a: Bool

l: List Bool

h✝: List.length (a :: l) = n + 1

h: List.length l = n

Bitvec.toNat (Vector.tail { val := a :: l, property := h✝ }) % 2 ^ (n + 1 - 1) =   Bitvec.toNat { val := a :: l, property := h✝ } % 2 ^ (n + 1 - 1)
n: β„•

a: Bool

l: List Bool

h: List.length (a :: l) = n + 1

Bitvec.toNat (Vector.tail { val := a :: l, property := h }) =   Bitvec.toNat { val := a :: l, property := h } % 2 ^ (n + 1 - 1)
n: β„•

a: Bool

l: List Bool

h✝: List.length (a :: l) = n + 1

h: List.length l = n

List.foldl addLsb 0 ↑(Vector.tail { val := a :: l, property := h✝ }) % 2 ^ (n + 1 - 1) =   ((2 ^ n * bif a then 1 else 0) + List.foldl addLsb 0 l) % 2 ^ (n + 1 - 1)
n: β„•

a: Bool

l: List Bool

h: List.length (a :: l) = n + 1

Bitvec.toNat (Vector.tail { val := a :: l, property := h }) =   Bitvec.toNat { val := a :: l, property := h } % 2 ^ (n + 1 - 1)
n: β„•

a: Bool

l: List Bool

h✝: List.length (a :: l) = n + 1

h: List.length l = n

List.foldl addLsb 0 l % 2 ^ n = ((2 ^ n * bif a then 1 else 0) + List.foldl addLsb 0 l) % 2 ^ n
n: β„•

a: Bool

l: List Bool

h: List.length (a :: l) = n + 1

Bitvec.toNat (Vector.tail { val := a :: l, property := h }) =   Bitvec.toNat { val := a :: l, property := h } % 2 ^ (n + 1 - 1)
n: β„•

a: Bool

l: List Bool

h✝: List.length (a :: l) = n + 1

h: List.length l = n

List.foldl addLsb 0 l % 2 ^ n = ((2 ^ n * bif a then 1 else 0) + List.foldl addLsb 0 l) % 2 ^ n
n: β„•

a: Bool

l: List Bool

h✝: List.length (a :: l) = n + 1

h: List.length l = n

List.foldl addLsb 0 l % 2 ^ n = ((bif a then 1 else 0) * 2 ^ n + List.foldl addLsb 0 l) % 2 ^ n
n: β„•

a: Bool

l: List Bool

h✝: List.length (a :: l) = n + 1

h: List.length l = n

List.foldl addLsb 0 l % 2 ^ n = ((2 ^ n * bif a then 1 else 0) + List.foldl addLsb 0 l) % 2 ^ n
n: β„•

a: Bool

l: List Bool

h✝: List.length (a :: l) = n + 1

h: List.length l = n

List.foldl addLsb 0 l % 2 ^ n = List.foldl addLsb 0 l % 2 ^ n
Goals accomplished! πŸ™


@[simp]
theorem 
toNat_add: βˆ€ {n : β„•} (x y : Bitvec n), Bitvec.toNat (x + y) = (Bitvec.toNat x + Bitvec.toNat y) % 2 ^ n
toNat_add {
n: β„•
n : 
Nat: Type
Nat} (
x: Bitvec n
x 
y: Bitvec n
y : 
Bitvec: β„• β†’ Type
Bitvec 
n: β„•
n) : (
x: Bitvec n
x + 
y: Bitvec n
y).
toNat: {n : β„•} β†’ Bitvec n β†’ β„•
toNat = (
x: Bitvec n
x.
toNat: {n : β„•} β†’ Bitvec n β†’ β„•
toNat + 
y: Bitvec n
y.
toNat: {n : β„•} β†’ Bitvec n β†’ β„•
toNat) % 
2: ?m.146225
2^
n: β„•
n := 
Goals accomplished! πŸ™
n: β„•

x, y: Bitvec n

Bitvec.toNat (x + y) = (Bitvec.toNat x + Bitvec.toNat y) % 2 ^ n
n: β„•

x, y: Bitvec n

Bitvec.toNat (Vector.tail (adc x y false)) = (Bitvec.toNat x + Bitvec.toNat y) % 2 ^ n
n: β„•

x, y: Bitvec n

Bitvec.toNat (x + y) = (Bitvec.toNat x + Bitvec.toNat y) % 2 ^ n
n: β„•

x, y: Bitvec n

Bitvec.toNat (Vector.tail (adc x y false)) = (Bitvec.toNat x + Bitvec.toNat y) % 2 ^ n
n: β„•

x, y: Bitvec n

Bitvec.toNat (adc x y false) % 2 ^ (n + 1 - 1) = (Bitvec.toNat x + Bitvec.toNat y) % 2 ^ n
n: β„•

x, y: Bitvec n

Bitvec.toNat (Vector.tail (adc x y false)) = (Bitvec.toNat x + Bitvec.toNat y) % 2 ^ n
n: β„•

x, y: Bitvec n

(Bitvec.toNat x + Bitvec.toNat y) % 2 ^ (n + 1 - 1) = (Bitvec.toNat x + Bitvec.toNat y) % 2 ^ n
n: β„•

x, y: Bitvec n

Bitvec.toNat (Vector.tail (adc x y false)) = (Bitvec.toNat x + Bitvec.toNat y) % 2 ^ n
n: β„•

x, y: Bitvec n

(Bitvec.toNat x + Bitvec.toNat y) % 2 ^ n = (Bitvec.toNat x + Bitvec.toNat y) % 2 ^ n
Goals accomplished! πŸ™



theorem 
toZMod_add: βˆ€ {n : β„•} (x y : Bitvec n), toZMod (x + y) = toZMod x + toZMod y
toZMod_add {
n: β„•
n : 
β„•: Type
β„•} (
x: Bitvec n
x 
y: Bitvec n
y : 
Bitvec: β„• β†’ Type
Bitvec 
n: β„•
n) : (
x: Bitvec n
x + 
y: Bitvec n
y).
toZMod: {n : β„•} β†’ Bitvec n β†’ ZMod (2 ^ n)
toZMod = (
x: Bitvec n
x.
toZMod: {n : β„•} β†’ Bitvec n β†’ ZMod (2 ^ n)
toZMod + 
y: Bitvec n
y.
toZMod: {n : β„•} β†’ Bitvec n β†’ ZMod (2 ^ n)
toZMod) := 
Goals accomplished! πŸ™
n: β„•

x, y: Bitvec n

toZMod (x + y) = toZMod x + toZMod y
n: β„•

x, y: Bitvec n

a
ZMod.val (toZMod (x + y)) = ZMod.val (toZMod x + toZMod y)
n: β„•

x, y: Bitvec n

toZMod (x + y) = toZMod x + toZMod y
n: β„•

x, y: Bitvec n

a
ZMod.val (toZMod (x + y)) = ZMod.val (toZMod x + toZMod y)
n: β„•

x, y: Bitvec n

a
Bitvec.toNat (x + y) = ZMod.val (toZMod x + toZMod y)
n: β„•

x, y: Bitvec n

a
ZMod.val (toZMod (x + y)) = ZMod.val (toZMod x + toZMod y)
n: β„•

x, y: Bitvec n

a
Bitvec.toNat (x + y) = (ZMod.val (toZMod x) + ZMod.val (toZMod y)) % 2 ^ n
n: β„•

x, y: Bitvec n

a
ZMod.val (toZMod (x + y)) = ZMod.val (toZMod x + toZMod y)
n: β„•

x, y: Bitvec n

a
(Bitvec.toNat x + Bitvec.toNat y) % 2 ^ n = (ZMod.val (toZMod x) + ZMod.val (toZMod y)) % 2 ^ n
n: β„•

x, y: Bitvec n

a
ZMod.val (toZMod (x + y)) = ZMod.val (toZMod x + toZMod y)
n: β„•

x, y: Bitvec n

a
(Bitvec.toNat x + Bitvec.toNat y) % 2 ^ n = (Bitvec.toNat x + ZMod.val (toZMod y)) % 2 ^ n
n: β„•

x, y: Bitvec n

a
ZMod.val (toZMod (x + y)) = ZMod.val (toZMod x + toZMod y)
n: β„•

x, y: Bitvec n

a
(Bitvec.toNat x + Bitvec.toNat y) % 2 ^ n = (Bitvec.toNat x + Bitvec.toNat y) % 2 ^ n
Goals accomplished! πŸ™


theorem 
ofZMod_add: βˆ€ {n : β„•} (x y : ZMod (2 ^ n)), ofZMod (x + y) = ofZMod x + ofZMod y
ofZMod_add {
n: β„•
n : 
β„•: Type
β„•} (
x: ZMod (2 ^ n)
x 
y: ZMod (2 ^ n)
y : 
ZMod: β„• β†’ Type
ZMod (
2: ?m.147846
2 ^
n: β„•
n)) : 
    
Bitvec.ofZMod: {n : β„•} β†’ ZMod (2 ^ n) β†’ Bitvec n
Bitvec.ofZMod (
x: ZMod (2 ^ n)
x + 
y: ZMod (2 ^ n)
y) = 
Bitvec.ofZMod: {n : β„•} β†’ ZMod (2 ^ n) β†’ Bitvec n
Bitvec.ofZMod 
x: ZMod (2 ^ n)
x + 
Bitvec.ofZMod: {n : β„•} β†’ ZMod (2 ^ n) β†’ Bitvec n
Bitvec.ofZMod 
y: ZMod (2 ^ n)
y := 
Goals accomplished! πŸ™
n: β„•

x, y: ZMod (2 ^ n)

ofZMod (x + y) = ofZMod x + ofZMod y
n: β„•

x, y: ZMod (2 ^ n)

ofZMod (x + y) = ofZMod x + ofZMod y
n: β„•

x, y: ZMod (2 ^ n)

ofZMod (toZMod (ofZMod x) + y) = ofZMod (toZMod (ofZMod x)) + ofZMod y
n: β„•

x, y: ZMod (2 ^ n)

ofZMod (x + y) = ofZMod x + ofZMod y
n: β„•

x, y: ZMod (2 ^ n)

ofZMod (toZMod (ofZMod x) + toZMod (ofZMod y)) = ofZMod (toZMod (ofZMod x)) + ofZMod (toZMod (ofZMod y))
n: β„•

x, y: ZMod (2 ^ n)

ofZMod (x + y) = ofZMod x + ofZMod y
n: β„•

x, y: ZMod (2 ^ n)

ofZMod (toZMod (ofZMod x + ofZMod y)) = ofZMod (toZMod (ofZMod x)) + ofZMod (toZMod (ofZMod y))
n: β„•

x, y: ZMod (2 ^ n)

ofZMod (x + y) = ofZMod x + ofZMod y
n: β„•

x, y: ZMod (2 ^ n)

ofZMod (toZMod (ofZMod x + ofZMod y)) = ofZMod x + ofZMod (toZMod (ofZMod y))
n: β„•

x, y: ZMod (2 ^ n)

ofZMod (x + y) = ofZMod x + ofZMod y
n: β„•

x, y: ZMod (2 ^ n)

ofZMod (toZMod (ofZMod x + ofZMod y)) = ofZMod x + ofZMod y
n: β„•

x, y: ZMod (2 ^ n)

ofZMod (x + y) = ofZMod x + ofZMod y
n: β„•

x, y: ZMod (2 ^ n)

ofZMod x + ofZMod y = ofZMod x + ofZMod y
Goals accomplished! πŸ™


theorem 
zero_def: βˆ€ {n : β„•}, 0 = { val := List.replicate n false, property := (_ : List.length ↑0 = n) }
zero_def : (
0: ?m.148270
0 : 
Bitvec: β„• β†’ Type
Bitvec 
n: ?m.148264
n) = ⟨
List.replicate: {Ξ± : Type ?u.148313} β†’ β„• β†’ Ξ± β†’ List Ξ±
List.replicate 
n: ?m.148264
n 
false: Bool
false, (
0: ?m.148318
0 : 
Bitvec: β„• β†’ Type
Bitvec 
n: ?m.148264
n).
2: βˆ€ {Ξ± : Sort ?u.148320} {p : Ξ± β†’ Prop} (self : Subtype p), p ↑self
2⟩  := 
rfl: βˆ€ {Ξ± : Sort ?u.148341} {a : Ξ±}, a = a
rfl

theorem 
toList_zero: βˆ€ {n : β„•}, Vector.toList 0 = List.replicate n false
toList_zero : 
Vector.toList: {Ξ± : Type ?u.148361} β†’ {n : β„•} β†’ Vector Ξ± n β†’ List Ξ±
Vector.toList (
0: ?m.148366
0 : 
Bitvec: β„• β†’ Type
Bitvec 
n: ?m.148357
n) = 
List.replicate: {Ξ± : Type ?u.148395} β†’ β„• β†’ Ξ± β†’ List Ξ±
List.replicate 
n: ?m.148357
n 
false: Bool
false := 
rfl: βˆ€ {Ξ± : Sort ?u.148401} {a : Ξ±}, a = a
rfl

@[simp]
theorem 
toNat_zero: βˆ€ {n : β„•}, Bitvec.toNat 0 = 0
toNat_zero : βˆ€ {
n: β„•
n : 
Nat: Type
Nat}, (
0: ?m.148433
0 : 
Bitvec: β„• β†’ Type
Bitvec 
n: β„•
n).
toNat: {n : β„•} β†’ Bitvec n β†’ β„•
toNat = 
0: ?m.148465
0
  | 
0: β„•
0 => 
rfl: βˆ€ {Ξ± : Sort ?u.148496} {a : Ξ±}, a = a
rfl
  | 
n: β„•
n+1 => 
Goals accomplished! πŸ™
n: β„•

Bitvec.toNat 0 = 0
Goals accomplished! πŸ™


theorem 
ofNat_zero: βˆ€ {w : β„•}, Bitvec.ofNat w 0 = 0
ofNat_zero : 
Bitvec.ofNat: (n : β„•) β†’ β„• β†’ Bitvec n
Bitvec.ofNat 
w: ?m.149369
w 
0: ?m.149374
0 = 
0: ?m.149385
0 := 
Goals accomplished! πŸ™
w: β„•

Bitvec.ofNat w 0 = 0
w: β„•

Bitvec.ofNat w 0 = 0
w: β„•

Bitvec.ofNat w (Bitvec.toNat 0) = 0
w: β„•

β„•
w: β„•

Bitvec.ofNat w 0 = 0
w: β„•

0 = 0
Goals accomplished! πŸ™


@[simp]
theorem 
toZMod_zero: βˆ€ {n : β„•}, toZMod 0 = 0
toZMod_zero : βˆ€ {
n: β„•
n : 
Nat: Type
Nat}, (
0: ?m.149459
0 : 
Bitvec: β„• β†’ Type
Bitvec 
n: β„•
n).
toZMod: {n : β„•} β†’ Bitvec n β†’ ZMod (2 ^ n)
toZMod = 
0: ?m.149507
0 := 
  
Goals accomplished! πŸ™
βˆ€ {n : β„•}, toZMod 0 = 0
Goals accomplished! πŸ™


@[simp]
theorem 
ofZMod_zero: βˆ€ {n : β„•}, ofZMod 0 = 0
ofZMod_zero : 
Bitvec.ofZMod: {n : β„•} β†’ ZMod (2 ^ n) β†’ Bitvec n
Bitvec.ofZMod (
0: ?m.151433
0 : 
ZMod: β„• β†’ Type
ZMod (
2: ?m.151361
2^
n: ?m.151351
n)) = 
0: ?m.151736
0 := 
Goals accomplished! πŸ™
n: β„•

ofZMod 0 = 0
n: β„•

ofZMod 0 = 0
n: β„•

ofZMod (toZMod 0) = 0
n: β„•

ofZMod 0 = 0
n: β„•

0 = 0
Goals accomplished! πŸ™


theorem 
toList_one: βˆ€ {n : β„•}, Vector.toList 1 = List.replicate n false ++ [true]
toList_one {
n: β„•
n : 
β„•: Type
β„•} : (
1: ?m.151914
1 : 
Bitvec: β„• β†’ Type
Bitvec (
n: β„•
n + 
1: ?m.151853
1)).
toList: {Ξ± : Type ?u.151938} β†’ {n : β„•} β†’ Vector Ξ± n β†’ List Ξ±
toList = 
List.replicate: {Ξ± : Type ?u.151949} β†’ β„• β†’ Ξ± β†’ List Ξ±
List.replicate 
n: β„•
n 
false: Bool
false ++ [
true: Bool
true] := 
rfl: βˆ€ {Ξ± : Sort ?u.151995} {a : Ξ±}, a = a
rfl 

theorem 
toNat_one: βˆ€ {n : β„•}, Bitvec.toNat 1 = if n = 0 then 0 else 1
toNat_one : βˆ€ {
n: β„•
n : 
Nat: Type
Nat}, (
1: ?m.152071
1 : 
Bitvec: β„• β†’ Type
Bitvec 
n: β„•
n).
toNat: {n : β„•} β†’ Bitvec n β†’ β„•
toNat = if 
n: β„•
n = 
0: ?m.152104
0 then 
0: ?m.152129
0 else 
1: ?m.152140
1
  | 
0: β„•
0 => 
rfl: βˆ€ {Ξ± : Sort ?u.152183} {a : Ξ±}, a = a
rfl
  | 
1: β„•
1 => 
rfl: βˆ€ {Ξ± : Sort ?u.152234} {a : Ξ±}, a = a
rfl
  | 
n: β„•
n+2 => 
Goals accomplished! πŸ™
n: β„•

Bitvec.toNat 1 = if n + 2 = 0 then 0 else 1
n: β„•

this: Bitvec.toNat 1 = if n + 1 = 0 then 0 else 1

Bitvec.toNat 1 = if n + 2 = 0 then 0 else 1
n: β„•

Bitvec.toNat 1 = if n + 2 = 0 then 0 else 1
n: β„•

this: addLsb (List.foldl addLsb 0 (List.replicate n false)) true = 1

addLsb (List.foldl addLsb (addLsb 0 false) (List.replicate n false)) true = 1
n: β„•

Bitvec.toNat 1 = if n + 2 = 0 then 0 else 1
n: β„•

this: List.foldl addLsb 0 (List.replicate n false) = 0

addLsb (List.foldl addLsb (addLsb 0 false) (List.replicate n false)) true = 1
n: β„•

Bitvec.toNat 1 = if n + 2 = 0 then 0 else 1
n: β„•

this: List.foldl addLsb 0 (List.replicate n false) = 0

addLsb (List.foldl addLsb (addLsb 0 false) (List.replicate n false)) true = 1
n: β„•

this: List.foldl addLsb 0 (List.replicate n false) = 0

addLsb (2 ^ List.length (List.replicate n false) * addLsb 0 false + List.foldl addLsb 0 (List.replicate n false)) true =   1
n: β„•

this: List.foldl addLsb 0 (List.replicate n false) = 0

addLsb (List.foldl addLsb (addLsb 0 false) (List.replicate n false)) true = 1
n: β„•

this: List.foldl addLsb 0 (List.replicate n false) = 0

addLsb (2 ^ List.length (List.replicate n false) * addLsb 0 false + 0) true = 1
n: β„•

this: List.foldl addLsb 0 (List.replicate n false) = 0

addLsb (2 ^ List.length (List.replicate n false) * addLsb 0 false + 0) true = 1
n: β„•

Bitvec.toNat 1 = if n + 2 = 0 then 0 else 1
Goals accomplished! πŸ™


@[simp]
theorem 
toZMod_one: βˆ€ {n : β„•}, toZMod 1 = 1
toZMod_one : βˆ€ {
n: β„•
n : 
Nat: Type
Nat}, (
1: ?m.155230
1 : 
Bitvec: β„• β†’ Type
Bitvec 
n: β„•
n).
toZMod: {n : β„•} β†’ Bitvec n β†’ ZMod (2 ^ n)
toZMod = 
1: ?m.155278
1 := 
Goals accomplished! πŸ™
βˆ€ {n : β„•}, toZMod 1 = 1
Goals accomplished! πŸ™


@[simp]
theorem 
ofZMod_one: βˆ€ {n : β„•}, ofZMod 1 = 1
ofZMod_one : 
Bitvec.ofZMod: {n : β„•} β†’ ZMod (2 ^ n) β†’ Bitvec n
Bitvec.ofZMod (
1: ?m.159402
1 : 
ZMod: β„• β†’ Type
ZMod (
2: ?m.159330
2^
n: ?m.159320
n)) = 
1: ?m.159615
1 := 
Goals accomplished! πŸ™
n: β„•

ofZMod 1 = 1
n: β„•

ofZMod 1 = 1
n: β„•

ofZMod (toZMod 1) = 1
n: β„•

ofZMod 1 = 1
n: β„•

1 = 1
Goals accomplished! πŸ™



instance: {n : β„•} β†’ SMul β„• (Bitvec n)
instance : 
SMul: Type ?u.159731 β†’ Type ?u.159730 β†’ Type (max?u.159731?u.159730)
SMul 
β„•: Type
β„• (
Bitvec: β„• β†’ Type
Bitvec 
n: ?m.159727
n) := ⟨
nsmulRec: {M : Type ?u.159743} β†’ [inst : Zero M] β†’ [inst : Add M] β†’ β„• β†’ M β†’ M
nsmulRec⟩

theorem 
nsmul_def: βˆ€ {n : β„•} (x : Bitvec n) (y : β„•), y β€’ x = nsmulRec y x
nsmul_def {
n: β„•
n : 
β„•: Type
β„•} (
x: Bitvec n
x : 
Bitvec: β„• β†’ Type
Bitvec 
n: β„•
n) (
y: β„•
y : 
β„•: Type
β„•) : 
y: β„•
y β€’ 
x: Bitvec n
x = 
nsmulRec: {M : Type ?u.160058} β†’ [inst : Zero M] β†’ [inst : Add M] β†’ β„• β†’ M β†’ M
nsmulRec 
y: β„•
y 
x: Bitvec n
x := 
rfl: βˆ€ {Ξ± : Sort ?u.160090} {a : Ξ±}, a = a
rfl

@[simp]
theorem 
toZMod_nsmul: βˆ€ {n : β„•} (x : Bitvec n) (y : β„•), toZMod (y β€’ x) = y β€’ toZMod x
toZMod_nsmul {
n: β„•
n : 
β„•: Type
β„•} (
x: Bitvec n
x : 
Bitvec: β„• β†’ Type
Bitvec 
n: β„•
n) (
y: β„•
y : 
β„•: Type
β„•) : (
y: β„•
y β€’ 
x: Bitvec n
x).
toZMod: {n : β„•} β†’ Bitvec n β†’ ZMod (2 ^ n)
toZMod = 
y: β„•
y β€’ 
x: Bitvec n
x.
toZMod: {n : β„•} β†’ Bitvec n β†’ ZMod (2 ^ n)
toZMod := 
Goals accomplished! πŸ™
n: β„•

x: Bitvec n

y: β„•

toZMod (y β€’ x) = y β€’ toZMod x
n: β„•

x: Bitvec n

y: β„•

toZMod (y β€’ x) = y β€’ toZMod x
n: β„•

x: Bitvec n

zero
toZMod (Nat.zero β€’ x) = Nat.zero β€’ toZMod x
Goals accomplished! πŸ™
Goals accomplished! πŸ™
n: β„•

x: Bitvec n

y: β„•

toZMod (y β€’ x) = y β€’ toZMod x
n: β„•

x: Bitvec n

y: β„•

ih: toZMod (y β€’ x) = y β€’ toZMod x

succ
toZMod (Nat.succ y β€’ x) = Nat.succ y β€’ toZMod x
n: β„•

x: Bitvec n

y: β„•

ih: toZMod (y β€’ x) = y β€’ toZMod x

succ
toZMod (Nat.succ y β€’ x) = Nat.succ y β€’ toZMod x
n: β„•

x: Bitvec n

y: β„•

ih: toZMod (y β€’ x) = y β€’ toZMod x

succ
toZMod (nsmulRec (Nat.succ y) x) = Nat.succ y β€’ toZMod x
n: β„•

x: Bitvec n

y: β„•

ih: toZMod (y β€’ x) = y β€’ toZMod x

succ
toZMod (Nat.succ y β€’ x) = Nat.succ y β€’ toZMod x
n: β„•

x: Bitvec n

y: β„•

ih: toZMod (y β€’ x) = y β€’ toZMod x

succ
toZMod (x + nsmulRec y x) = Nat.succ y β€’ toZMod x
n: β„•

x: Bitvec n

y: β„•

ih: toZMod (y β€’ x) = y β€’ toZMod x

succ
toZMod (Nat.succ y β€’ x) = Nat.succ y β€’ toZMod x
n: β„•

x: Bitvec n

y: β„•

ih: toZMod (y β€’ x) = y β€’ toZMod x

succ
toZMod x + toZMod (nsmulRec y x) = Nat.succ y β€’ toZMod x
n: β„•

x: Bitvec n

y: β„•

ih: toZMod (y β€’ x) = y β€’ toZMod x

succ
toZMod (Nat.succ y β€’ x) = Nat.succ y β€’ toZMod x
n: β„•

x: Bitvec n

y: β„•

ih: toZMod (y β€’ x) = y β€’ toZMod x

succ
toZMod x + toZMod (y β€’ x) = Nat.succ y β€’ toZMod x
n: β„•

x: Bitvec n

y: β„•

ih: toZMod (y β€’ x) = y β€’ toZMod x

succ
toZMod (Nat.succ y β€’ x) = Nat.succ y β€’ toZMod x
n: β„•

x: Bitvec n

y: β„•

ih: toZMod (y β€’ x) = y β€’ toZMod x

succ
toZMod x + y β€’ toZMod x = Nat.succ y β€’ toZMod x
n: β„•

x: Bitvec n

y: β„•

ih: toZMod (y β€’ x) = y β€’ toZMod x

succ
toZMod x + y β€’ toZMod x = Nat.succ y β€’ toZMod x
n: β„•

x: Bitvec n

y: β„•

ih: toZMod (y β€’ x) = y β€’ toZMod x

succ
toZMod x + y β€’ toZMod x = Nat.succ y β€’ toZMod x
n: β„•

x: Bitvec n

y: β„•

ih: toZMod (y β€’ x) = y β€’ toZMod x

succ
toZMod (Nat.succ y β€’ x) = Nat.succ y β€’ toZMod x
Goals accomplished! πŸ™


theorem 
toInt_sub_aux: βˆ€ {x y : List Bool},
  List.length x = List.length y β†’
    (↑(List.foldl addLsb 0 (List.mapAccumrβ‚‚ (fun x y c => (Bitvec.carry (!x) y c, Bitvec.xor3 x y c)) x y false).snd) -         2 ^ List.length x *           bif (List.mapAccumrβ‚‚ (fun x y c => (Bitvec.carry (!x) y c, Bitvec.xor3 x y c)) x y false).fst then 1 else 0) =       ↑(List.foldl addLsb 0 x) + -↑(List.foldl addLsb 0 y)
toInt_sub_aux : βˆ€ {
x: List Bool
x 
y: List Bool
y : 
List: Type ?u.164902 β†’ Type ?u.164902
List 
Bool: Type
Bool} (
_hx: List.length x = List.length y
_hx : 
List.length: {Ξ± : Type ?u.164909} β†’ List Ξ± β†’ β„•
List.length 
x: List Bool
x = 
List.length: {Ξ± : Type ?u.164913} β†’ List Ξ± β†’ β„•
List.length 
y: List Bool
y),
    (↑(
List.foldl: {Ξ± : Type ?u.164925} β†’ {Ξ² : Type ?u.164924} β†’ (Ξ± β†’ Ξ² β†’ Ξ±) β†’ Ξ± β†’ List Ξ² β†’ Ξ±
List.foldl 
addLsb: β„• β†’ Bool β†’ β„•
addLsb 
0: ?m.164935
0 (
List.mapAccumrβ‚‚: {Ο† : Type ?u.164948} β†’
  {Οƒ : Type ?u.164947} β†’
    {Ξ± : Type ?u.164946} β†’ {Ξ² : Type ?u.164945} β†’ (Ξ± β†’ Ξ² β†’ Οƒ β†’ Οƒ Γ— Ο†) β†’ List Ξ± β†’ List Ξ² β†’ Οƒ β†’ Οƒ Γ— List Ο†
List.mapAccumrβ‚‚ (fun 
x: ?m.164954
x 
y: ?m.164957
y 
c: ?m.164960
c => (
Bitvec.carry: Bool β†’ Bool β†’ Bool β†’ Bool
Bitvec.carry (!
x: ?m.164954
x) 
y: ?m.164957
y 
c: ?m.164960
c, 
Bitvec.xor3: Bool β†’ Bool β†’ Bool β†’ Bool
Bitvec.xor3 
x: ?m.164954
x 
y: ?m.164957
y 
c: ?m.164960
c)) 
x: List Bool
x 
y: List Bool
y 
false: Bool
false).
snd: {Ξ± : Type ?u.164979} β†’ {Ξ² : Type ?u.164978} β†’ Ξ± Γ— Ξ² β†’ Ξ²
snd) : 
β„€: Type
β„€)
    - 
2: ?m.165039
2 ^ 
x: List Bool
x.
length: {Ξ± : Type ?u.165048} β†’ List Ξ± β†’ β„•
length * 
cond: {Ξ± : Type ?u.165052} β†’ Bool β†’ Ξ± β†’ Ξ± β†’ Ξ±
cond (
List.mapAccumrβ‚‚: {Ο† : Type ?u.165057} β†’
  {Οƒ : Type ?u.165056} β†’
    {Ξ± : Type ?u.165055} β†’ {Ξ² : Type ?u.165054} β†’ (Ξ± β†’ Ξ² β†’ Οƒ β†’ Οƒ Γ— Ο†) β†’ List Ξ± β†’ List Ξ² β†’ Οƒ β†’ Οƒ Γ— List Ο†
List.mapAccumrβ‚‚ (fun 
x: ?m.165063
x 
y: ?m.165066
y 
c: ?m.165069
c => (
Bitvec.carry: Bool β†’ Bool β†’ Bool β†’ Bool
Bitvec.carry (!
x: ?m.165063
x) 
y: ?m.165066
y 
c: ?m.165069
c, 
Bitvec.xor3: Bool β†’ Bool β†’ Bool β†’ Bool
Bitvec.xor3 
x: ?m.165063
x 
y: ?m.165066
y 
c: ?m.165069
c)) 
x: List Bool
x 
y: List Bool
y 
false: Bool
false).
fst: {Ξ± : Type ?u.165086} β†’ {Ξ² : Type ?u.165085} β†’ Ξ± Γ— Ξ² β†’ Ξ±
fst 
1: ?m.165090
1 
0: ?m.165100
0 =
  ↑(
List.foldl: {Ξ± : Type ?u.165444} β†’ {Ξ² : Type ?u.165443} β†’ (Ξ± β†’ Ξ² β†’ Ξ±) β†’ Ξ± β†’ List Ξ² β†’ Ξ±
List.foldl 
addLsb: β„• β†’ Bool β†’ β„•
addLsb 
0: ?m.165454
0 
x: List Bool
x) + -↑(
List.foldl: {Ξ± : Type ?u.165488} β†’ {Ξ² : Type ?u.165487} β†’ (Ξ± β†’ Ξ² β†’ Ξ±) β†’ Ξ± β†’ List Ξ² β†’ Ξ±
List.foldl 
addLsb: β„• β†’ Bool β†’ β„•
addLsb 
0: ?m.165498
0 
y: List Bool
y) 
| [], [], _ => 
rfl: βˆ€ {Ξ± : Sort ?u.165916} {a : Ξ±}, a = a
rfl
|  
a: Bool
a::
x: List Bool
x, 
b: Bool
b::
y: List Bool
y, 
h: List.length (a :: x) = List.length (b :: y)
h => 
Goals accomplished! πŸ™
a: Bool

x: List Bool

b: Bool

y: List Bool

h: List.length (a :: x) = List.length (b :: y)

(↑(List.foldl addLsb 0
        (List.mapAccumrβ‚‚ (fun x y c => (Bitvec.carry (!x) y c, Bitvec.xor3 x y c)) (a :: x) (b :: y) false).snd) -     2 ^ List.length (a :: x) *       bif (List.mapAccumrβ‚‚ (fun x y c => (Bitvec.carry (!x) y c, Bitvec.xor3 x y c)) (a :: x) (b :: y) false).fst then 1
      else 0) =   ↑(List.foldl addLsb 0 (a :: x)) + -↑(List.foldl addLsb 0 (b :: y))
a: Bool

x: List Bool

b: Bool

y: List Bool

h: List.length x = List.length y

(↑(List.foldl addLsb 0
        (List.mapAccumrβ‚‚ (fun x y c => (Bitvec.carry (!x) y c, Bitvec.xor3 x y c)) (a :: x) (b :: y) false).snd) -     2 ^ List.length (a :: x) *       bif (List.mapAccumrβ‚‚ (fun x y c => (Bitvec.carry (!x) y c, Bitvec.xor3 x y c)) (a :: x) (b :: y) false).fst then 1
      else 0) =   ↑(List.foldl addLsb 0 (a :: x)) + -↑(List.foldl addLsb 0 (b :: y))
a: Bool

x: List Bool

b: Bool

y: List Bool

h: List.length (a :: x) = List.length (b :: y)

(↑(List.foldl addLsb 0
        (List.mapAccumrβ‚‚ (fun x y c => (Bitvec.carry (!x) y c, Bitvec.xor3 x y c)) (a :: x) (b :: y) false).snd) -     2 ^ List.length (a :: x) *       bif (List.mapAccumrβ‚‚ (fun x y c => (Bitvec.carry (!x) y c, Bitvec.xor3 x y c)) (a :: x) (b :: y) false).fst then 1
      else 0) =   ↑(List.foldl addLsb 0 (a :: x)) + -↑(List.foldl addLsb 0 (b :: y))
a: Bool

x: List Bool

b: Bool

y: List Bool

h: List.length x = List.length y

(↑(List.foldl addLsb 0
        (List.mapAccumrβ‚‚ (fun x y c => (Bitvec.carry (!x) y c, Bitvec.xor3 x y c)) (a :: x) (b :: y) false).snd) -     2 ^ List.length (a :: x) *       bif (List.mapAccumrβ‚‚ (fun x y c => (Bitvec.carry (!x) y c, Bitvec.xor3 x y c)) (a :: x) (b :: y) false).fst then 1
      else 0) =   ↑(List.foldl addLsb 0 (a :: x)) + -↑(List.foldl addLsb 0 (b :: y))
a: Bool

x: List Bool

b: Bool

y: List Bool

h: List.length x = List.length y

(↑(List.foldl addLsb 0
        (List.mapAccumrβ‚‚ (fun x y c => (Bitvec.carry (!x) y c, Bitvec.xor3 x y c)) (a :: x) (b :: y) false).snd) -     2 ^ List.length (a :: x) *       bif (List.mapAccumrβ‚‚ (fun x y c => (Bitvec.carry (!x) y c, Bitvec.xor3 x y c)) (a :: x) (b :: y) false).fst then 1
      else 0) =   ↑((2 ^ List.length x * bif a then 1 else 0) + List.foldl addLsb 0 x) + -↑(List.foldl addLsb 0 (b :: y))
a: Bool

x: List Bool

b: Bool

y: List Bool

h: List.length x = List.length y

(↑(List.foldl addLsb 0
        (List.mapAccumrβ‚‚ (fun x y c => (Bitvec.carry (!x) y c, Bitvec.xor3 x y c)) (a :: x) (b :: y) false).snd) -     2 ^ List.length (a :: x) *       bif (List.mapAccumrβ‚‚ (fun x y c => (Bitvec.carry (!x) y c, Bitvec.xor3 x y c)) (a :: x) (b :: y) false).fst then 1
      else 0) =   ↑(List.foldl addLsb 0 (a :: x)) + -↑(List.foldl addLsb 0 (b :: y))
a: Bool

x: List Bool

b: Bool

y: List Bool

h: List.length x = List.length y

(↑(List.foldl addLsb 0
        (List.mapAccumrβ‚‚ (fun x y c => (Bitvec.carry (!x) y c, Bitvec.xor3 x y c)) (a :: x) (b :: y) false).snd) -     2 ^ List.length (a :: x) *       bif (List.mapAccumrβ‚‚ (fun x y c => (Bitvec.carry (!x) y c, Bitvec.xor3 x y c)) (a :: x) (b :: y) false).fst then 1
      else 0) =   ↑((2 ^ List.length x * bif a then 1 else 0) + List.foldl addLsb 0 x) +     -↑((2 ^ List.length y * bif b then 1 else 0) + List.foldl addLsb 0 y)
a: Bool

x: List Bool

b: Bool

y: List Bool

h: List.length x = List.length y

(↑(List.foldl addLsb 0
        (List.mapAccumrβ‚‚ (fun x y c => (Bitvec.carry (!x) y c, Bitvec.xor3 x y c)) (a :: x) (b :: y) false).snd) -     2 ^ List.length (a :: x) *       bif (List.mapAccumrβ‚‚ (fun x y c => (Bitvec.carry (!x) y c, Bitvec.xor3 x y c)) (a :: x) (b :: y) false).fst then 1
      else 0) =   ↑(List.foldl addLsb 0 (a :: x)) + -↑(List.foldl addLsb 0 (b :: y))
a: Bool

x: List Bool

b: Bool

y: List Bool

h: List.length x = List.length y

(↑(List.foldl addLsb 0
        (List.mapAccumrβ‚‚ (fun x y c => (Bitvec.carry (!x) y c, Bitvec.xor3 x y c)) (a :: x) (b :: y) false).snd) -     2 ^ List.length (a :: x) *       bif (List.mapAccumrβ‚‚ (fun x y c => (Bitvec.carry (!x) y c, Bitvec.xor3 x y c)) (a :: x) (b :: y) false).fst then 1
      else 0) =   ↑(2 ^ List.length x * bif a then 1 else 0) + ↑(List.foldl addLsb 0 x) +     -↑((2 ^ List.length y * bif b then 1 else 0) + List.foldl addLsb 0 y)
a: Bool

x: List Bool

b: Bool

y: List Bool

h: List.length x = List.length y

(↑(List.foldl addLsb 0
        (List.mapAccumrβ‚‚ (fun x y c => (Bitvec.carry (!x) y c, Bitvec.xor3 x y c)) (a :: x) (b :: y) false).snd) -     2 ^ List.length (a :: x) *       bif (List.mapAccumrβ‚‚ (fun x y c => (Bitvec.carry (!x) y c, Bitvec.xor3 x y c)) (a :: x) (b :: y) false).fst then 1
      else 0) =   ↑(List.foldl addLsb 0 (a :: x)) + -↑(List.foldl addLsb 0 (b :: y))
a: Bool

x: List Bool

b: Bool

y: List Bool

h: List.length x = List.length y

(↑(List.foldl addLsb 0
        (List.mapAccumrβ‚‚ (fun x y c => (Bitvec.carry (!x) y c, Bitvec.xor3 x y c)) (a :: x) (b :: y) false).snd) -     2 ^ List.length (a :: x) *       bif (List.mapAccumrβ‚‚ (fun x y c => (Bitvec.carry (!x) y c, Bitvec.xor3 x y c)) (a :: x) (b :: y) false).fst then 1
      else 0) =   ↑(2 ^ List.length x * bif a then 1 else 0) + ↑(List.foldl addLsb 0 x) +     -(↑(2 ^ List.length y * bif b then 1 else 0) + ↑(List.foldl addLsb 0 y))
a: Bool

x: List Bool

b: Bool

y: List Bool

h: List.length x = List.length y

(↑(List.foldl addLsb 0
        (List.mapAccumrβ‚‚ (fun x y c => (Bitvec.carry (!x) y c, Bitvec.xor3 x y c)) (a :: x) (b :: y) false).snd) -     2 ^ List.length (a :: x) *       bif (List.mapAccumrβ‚‚ (fun x y c => (Bitvec.carry (!x) y c, Bitvec.xor3 x y c)) (a :: x) (b :: y) false).fst then 1
      else 0) =   ↑(List.foldl addLsb 0 (a :: x)) + -↑(List.foldl addLsb 0 (b :: y))
a: Bool

x: List Bool

b: Bool

y: List Bool

h: List.length x = List.length y

(↑(List.foldl addLsb 0
        (List.mapAccumrβ‚‚ (fun x y c => (Bitvec.carry (!x) y c, Bitvec.xor3 x y c)) (a :: x) (b :: y) false).snd) -     2 ^ List.length (a :: x) *       bif (List.mapAccumrβ‚‚ (fun x y c => (Bitvec.carry (!x) y c, Bitvec.xor3 x y c)) (a :: x) (b :: y) false).fst then 1
      else 0) =   ↑(2 ^ List.length x * bif a then 1 else 0) + ↑(List.foldl addLsb 0 x) +     (-↑(2 ^ List.length y * bif b then 1 else 0) + -↑(List.foldl addLsb 0 y))
a: Bool

x: List Bool

b: Bool

y: List Bool

h: List.length x = List.length y

(↑(List.foldl addLsb 0
        (List.mapAccumrβ‚‚ (fun x y c => (Bitvec.carry (!x) y c, Bitvec.xor3 x y c)) (a :: x) (b :: y) false).snd) -     2 ^ List.length (a :: x) *       bif (List.mapAccumrβ‚‚ (fun x y c => (Bitvec.carry (!x) y c, Bitvec.xor3 x y c)) (a :: x) (b :: y) false).fst then 1
      else 0) =   ↑(List.foldl addLsb 0 (a :: x)) + -↑(List.foldl addLsb 0 (b :: y))
a: Bool

x: List Bool

b: Bool

y: List Bool

h: List.length x = List.length y

(↑(List.foldl addLsb 0
        (List.mapAccumrβ‚‚ (fun x y c => (Bitvec.carry (!x) y c, Bitvec.xor3 x y c)) (a :: x) (b :: y) false).snd) -     2 ^ List.length (a :: x) *       bif (List.mapAccumrβ‚‚ (fun x y c => (Bitvec.carry (!x) y c, Bitvec.xor3 x y c)) (a :: x) (b :: y) false).fst then 1
      else 0) =   ↑(2 ^ List.length x * bif a then 1 else 0) + -↑(2 ^ List.length y * bif b then 1 else 0) +     (↑(List.foldl addLsb 0 x) + -↑(List.foldl addLsb 0 y))
a: Bool

x: List Bool

b: Bool

y: List Bool

h: List.length x = List.length y

(↑(List.foldl addLsb 0
        (List.mapAccumrβ‚‚ (fun x y c => (Bitvec.carry (!x) y c, Bitvec.xor3 x y c)) (a :: x) (b :: y) false).snd) -     2 ^ List.length (a :: x) *       bif (List.mapAccumrβ‚‚ (fun x y c => (Bitvec.carry (!x) y c, Bitvec.xor3 x y c)) (a :: x) (b :: y) false).fst then 1
      else 0) =   ↑(List.foldl addLsb 0 (a :: x)) + -↑(List.foldl addLsb 0 (b :: y))
a: Bool

x: List Bool

b: Bool

y: List Bool

h: List.length x = List.length y

(↑(List.foldl addLsb 0
        (List.mapAccumrβ‚‚ (fun x y c => (Bitvec.carry (!x) y c, Bitvec.xor3 x y c)) (a :: x) (b :: y) false).snd) -     2 ^ List.length (a :: x) *       bif (List.mapAccumrβ‚‚ (fun x y c => (Bitvec.carry (!x) y c, Bitvec.xor3 x y c)) (a :: x) (b :: y) false).fst then 1
      else 0) =   ↑(2 ^ List.length x * bif a then 1 else 0) + -↑(2 ^ List.length y * bif b then 1 else 0) +     (↑(List.foldl addLsb 0 (List.mapAccumrβ‚‚ (fun x y c => (Bitvec.carry (!x) y c, Bitvec.xor3 x y c)) x y false).snd) -       2 ^ List.length x *         bif (List.mapAccumrβ‚‚ (fun x y c => (Bitvec.carry (!x) y c, Bitvec.xor3 x y c)) x y false).fst then 1 else 0)
a: Bool

x: List Bool

b: Bool

y: List Bool

h: List.length x = List.length y

(↑(List.foldl addLsb 0
        (List.mapAccumrβ‚‚ (fun x y c => (Bitvec.carry (!x) y c, Bitvec.xor3 x y c)) (a :: x) (b :: y) false).snd) -     2 ^ List.length (a :: x) *       bif (List.mapAccumrβ‚‚ (fun x y c => (Bitvec.carry (!x) y c, Bitvec.xor3 x y c)) (a :: x) (b :: y) false).fst then 1
      else 0) =   ↑(List.foldl addLsb 0 (a :: x)) + -↑(List.foldl addLsb 0 (b :: y))
a: Bool

x: List Bool

b: Bool

y: List Bool

h: List.length x = List.length y

(↑(List.foldl addLsb 0
        (let r := List.mapAccumrβ‚‚ (fun x y c => (Bitvec.carry (!x) y c, Bitvec.xor3 x y c)) x y false;
          let q := (Bitvec.carry (!a) b r.fst, Bitvec.xor3 a b r.fst);
          (q.fst, q.snd :: r.snd)).snd) -     2 ^ List.length (a :: x) *       bif
          (let r := List.mapAccumrβ‚‚ (fun x y c => (Bitvec.carry (!x) y c, Bitvec.xor3 x y c)) x y false;
            let q := (Bitvec.carry (!a) b r.fst, Bitvec.xor3 a b r.fst);
            (q.fst, q.snd :: r.snd)).fst then
        1
      else 0) =   ↑(2 ^ List.length x * bif a then 1 else 0) + -↑(2 ^ List.length y * bif b then 1 else 0) +     (↑(List.foldl addLsb 0 (List.mapAccumrβ‚‚ (fun x y c => (Bitvec.carry (!x) y c, Bitvec.xor3 x y c)) x y false).snd) -       2 ^ List.length x *         bif (List.mapAccumrβ‚‚ (fun x y c => (Bitvec.carry (!x) y c, Bitvec.xor3 x y c)) x y false).fst then 1 else 0)
a: Bool

x: List Bool

b: Bool

y: List Bool

h: List.length x = List.length y

(↑(List.foldl addLsb 0
        (let r := List.mapAccumrβ‚‚ (fun x y c => (Bitvec.carry (!x) y c, Bitvec.xor3 x y c)) x y false;
          let q := (Bitvec.carry (!a) b r.fst, Bitvec.xor3 a b r.fst);
          (q.fst, q.snd :: r.snd)).snd) -     2 ^ List.length (a :: x) *       bif
          (let r := List.mapAccumrβ‚‚ (fun x y c => (Bitvec.carry (!x) y c, Bitvec.xor3 x y c)) x y false;
            let q := (Bitvec.carry (!a) b r.fst, Bitvec.xor3 a b r.fst);
            (q.fst, q.snd :: r.snd)).fst then
        1
      else 0) =   ↑(2 ^ List.length x * bif a then 1 else 0) + -↑(2 ^ List.length y * bif b then 1 else 0) +     (↑(List.foldl addLsb 0 (List.mapAccumrβ‚‚ (fun x y c => (Bitvec.carry (!x) y c, Bitvec.xor3 x y c)) x y false).snd) -       2 ^ List.length x *         bif (List.mapAccumrβ‚‚ (fun x y c => (Bitvec.carry (!x) y c, Bitvec.xor3 x y c)) x y false).fst then 1 else 0)
a: Bool

x: List Bool

b: Bool

y: List Bool

h: List.length (a :: x) = List.length (b :: y)

(↑(List.foldl addLsb 0
        (List.mapAccumrβ‚‚ (fun x y c => (Bitvec.carry (!x) y c, Bitvec.xor3 x y c)) (a :: x) (b :: y) false).snd) -     2 ^ List.length (a :: x) *       bif (List.mapAccumrβ‚‚ (fun x y c => (Bitvec.carry (!x) y c, Bitvec.xor3 x y c)) (a :: x) (b :: y) false).fst then 1
      else 0) =   ↑(List.foldl addLsb 0 (a :: x)) + -↑(List.foldl addLsb 0 (b :: y))
a: Bool

x: List Bool

b: Bool

y: List Bool

h: List.length x = List.length y

(↑(List.foldl addLsb 0
        (xor (xor a b) (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).fst ::           (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).snd)) -     2 ^ List.length (a :: x) *       bif
          !a && b ||               !a && (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).fst ||             b && (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).fst then
        1
      else 0) =   ↑(2 ^ List.length x * bif a then 1 else 0) + -↑(2 ^ List.length y * bif b then 1 else 0) +     (↑(List.foldl addLsb 0
          (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).snd) -       2 ^ List.length x *         bif (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).fst then 1
        else 0)
a: Bool

x: List Bool

b: Bool

y: List Bool

h: List.length (a :: x) = List.length (b :: y)

(↑(List.foldl addLsb 0
        (List.mapAccumrβ‚‚ (fun x y c => (Bitvec.carry (!x) y c, Bitvec.xor3 x y c)) (a :: x) (b :: y) false).snd) -     2 ^ List.length (a :: x) *       bif (List.mapAccumrβ‚‚ (fun x y c => (Bitvec.carry (!x) y c, Bitvec.xor3 x y c)) (a :: x) (b :: y) false).fst then 1
      else 0) =   ↑(List.foldl addLsb 0 (a :: x)) + -↑(List.foldl addLsb 0 (b :: y))
a: Bool

x: List Bool

b: Bool

y: List Bool

h: List.length x = List.length y

(↑(List.foldl addLsb 0
        (xor (xor a b) (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).fst ::           (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).snd)) -     2 ^ List.length (a :: x) *       bif
          !a && b ||               !a && (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).fst ||             b && (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).fst then
        1
      else 0) =   ↑(2 ^ List.length x * bif a then 1 else 0) + -↑(2 ^ List.length y * bif b then 1 else 0) +     (↑(List.foldl addLsb 0
          (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).snd) -       2 ^ List.length x *         bif (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).fst then 1
        else 0)
a: Bool

x: List Bool

b: Bool

y: List Bool

h: List.length x = List.length y

(↑(2 ^             List.length
              (xor (xor a b)
                  (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).fst ::                 (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).snd) *           0 +         List.foldl addLsb 0
          (xor (xor a b)
              (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).fst ::             (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).snd)) -     2 ^ List.length (a :: x) *       bif
          !a && b ||               !a && (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).fst ||             b && (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).fst then
        1
      else 0) =   ↑(2 ^ List.length x * bif a then 1 else 0) + -↑(2 ^ List.length y * bif b then 1 else 0) +     (↑(List.foldl addLsb 0
          (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).snd) -       2 ^ List.length x *         bif (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).fst then 1
        else 0)
a: Bool

x: List Bool

b: Bool

y: List Bool

h: List.length x = List.length y

(↑(List.foldl addLsb 0
        (xor (xor a b) (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).fst ::           (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).snd)) -     2 ^ List.length (a :: x) *       bif
          !a && b ||               !a && (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).fst ||             b && (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).fst then
        1
      else 0) =   ↑(2 ^ List.length x * bif a then 1 else 0) + -↑(2 ^ List.length y * bif b then 1 else 0) +     (↑(List.foldl addLsb 0
          (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).snd) -       2 ^ List.length x *         bif (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).fst then 1
        else 0)
a: Bool

x: List Bool

b: Bool

y: List Bool

h: List.length x = List.length y

(↑(2 ^             List.length
              (xor (xor a b)
                  (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).fst ::                 (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).snd) *           0 +         ((2 ^               List.length
                (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).snd *             bif
                xor (xor a b)
                  (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).fst then
              1
            else 0) +           List.foldl addLsb 0
            (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).snd)) -     2 ^ List.length (a :: x) *       bif
          !a && b ||               !a && (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).fst ||             b && (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).fst then
        1
      else 0) =   ↑(2 ^ List.length x * bif a then 1 else 0) + -↑(2 ^ List.length y * bif b then 1 else 0) +     (↑(List.foldl addLsb 0
          (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).snd) -       2 ^ List.length x *         bif (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).fst then 1
        else 0)
a: Bool

x: List Bool

b: Bool

y: List Bool

h: List.length x = List.length y

(↑(2 ^             List.length
              (xor (xor a b)
                  (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).fst ::                 (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).snd) *           0 +         ((2 ^               List.length
                (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).snd *             bif
                xor (xor a b)
                  (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).fst then
              1
            else 0) +           List.foldl addLsb 0
            (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).snd)) -     2 ^ List.length (a :: x) *       bif
          !a && b ||               !a && (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).fst ||             b && (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).fst then
        1
      else 0) =   ↑(2 ^ List.length x * bif a then 1 else 0) + -↑(2 ^ List.length y * bif b then 1 else 0) +     (↑(List.foldl addLsb 0
          (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).snd) -       2 ^ List.length x *         bif (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).fst then 1
        else 0)
a: Bool

x: List Bool

b: Bool

y: List Bool

h: List.length (a :: x) = List.length (b :: y)

(↑(List.foldl addLsb 0
        (List.mapAccumrβ‚‚ (fun x y c => (Bitvec.carry (!x) y c, Bitvec.xor3 x y c)) (a :: x) (b :: y) false).snd) -     2 ^ List.length (a :: x) *       bif (List.mapAccumrβ‚‚ (fun x y c => (Bitvec.carry (!x) y c, Bitvec.xor3 x y c)) (a :: x) (b :: y) false).fst then 1
      else 0) =   ↑(List.foldl addLsb 0 (a :: x)) + -↑(List.foldl addLsb 0 (b :: y))
x: List Bool

b: Bool

y: List Bool

h: List.length x = List.length y

false
(↑(2 ^             List.length
              (xor (xor false b)
                  (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).fst ::                 (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).snd) *           0 +         ((2 ^               List.length
                (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).snd *             bif
                xor (xor false b)
                  (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).fst then
              1
            else 0) +           List.foldl addLsb 0
            (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).snd)) -     2 ^ List.length (false :: x) *       bif
          !false && b ||               !false &&                 (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).fst ||             b && (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).fst then
        1
      else 0) =   ↑(2 ^ List.length x * bif false then 1 else 0) + -↑(2 ^ List.length y * bif b then 1 else 0) +     (↑(List.foldl addLsb 0
          (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).snd) -       2 ^ List.length x *         bif (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).fst then 1
        else 0)
x: List Bool

b: Bool

y: List Bool

h: List.length x = List.length y

true
(↑(2 ^             List.length
              (xor (xor true b)
                  (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).fst ::                 (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).snd) *           0 +         ((2 ^               List.length
                (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).snd *             bif
                xor (xor true b)
                  (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).fst then
              1
            else 0) +           List.foldl addLsb 0
            (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).snd)) -     2 ^ List.length (true :: x) *       bif
          !true && b ||               !true && (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).fst ||             b && (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).fst then
        1
      else 0) =   ↑(2 ^ List.length x * bif true then 1 else 0) + -↑(2 ^ List.length y * bif b then 1 else 0) +     (↑(List.foldl addLsb 0
          (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).snd) -       2 ^ List.length x *         bif (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).fst then 1
        else 0)
a: Bool

x: List Bool

b: Bool

y: List Bool

h: List.length x = List.length y

(↑(2 ^             List.length
              (xor (xor a b)
                  (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).fst ::                 (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).snd) *           0 +         ((2 ^               List.length
                (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).snd *             bif
                xor (xor a b)
                  (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).fst then
              1
            else 0) +           List.foldl addLsb 0
            (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).snd)) -     2 ^ List.length (a :: x) *       bif
          !a && b ||               !a && (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).fst ||             b && (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).fst then
        1
      else 0) =   ↑(2 ^ List.length x * bif a then 1 else 0) + -↑(2 ^ List.length y * bif b then 1 else 0) +     (↑(List.foldl addLsb 0
          (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).snd) -       2 ^ List.length x *         bif (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).fst then 1
        else 0)
x: List Bool

b: Bool

y: List Bool

h: List.length x = List.length y

false
(↑(2 ^             List.length
              (xor (xor false b)
                  (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).fst ::                 (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).snd) *           0 +         ((2 ^               List.length
                (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).snd *             bif
                xor (xor false b)
                  (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).fst then
              1
            else 0) +           List.foldl addLsb 0
            (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).snd)) -     2 ^ List.length (false :: x) *       bif
          !false && b ||               !false &&                 (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).fst ||             b && (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).fst then
        1
      else 0) =   ↑(2 ^ List.length x * bif false then 1 else 0) + -↑(2 ^ List.length y * bif b then 1 else 0) +     (↑(List.foldl addLsb 0
          (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).snd) -       2 ^ List.length x *         bif (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).fst then 1
        else 0)
x: List Bool

b: Bool

y: List Bool

h: List.length x = List.length y

true
(↑(2 ^             List.length
              (xor (xor true b)
                  (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).fst ::                 (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).snd) *           0 +         ((2 ^               List.length
                (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).snd *             bif
                xor (xor true b)
                  (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).fst then
              1
            else 0) +           List.foldl addLsb 0
            (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).snd)) -     2 ^ List.length (true :: x) *       bif
          !true && b ||               !true && (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).fst ||             b && (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).fst then
        1
      else 0) =   ↑(2 ^ List.length x * bif true then 1 else 0) + -↑(2 ^ List.length y * bif b then 1 else 0) +     (↑(List.foldl addLsb 0
          (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).snd) -       2 ^ List.length x *         bif (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).fst then 1
        else 0)
a: Bool

x: List Bool

b: Bool

y: List Bool

h: List.length x = List.length y

(↑(2 ^             List.length
              (xor (xor a b)
                  (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).fst ::                 (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).snd) *           0 +         ((2 ^               List.length
                (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).snd *             bif
                xor (xor a b)
                  (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).fst then
              1
            else 0) +           List.foldl addLsb 0
            (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).snd)) -     2 ^ List.length (a :: x) *       bif
          !a && b ||               !a && (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).fst ||             b && (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).fst then
        1
      else 0) =   ↑(2 ^ List.length x * bif a then 1 else 0) + -↑(2 ^ List.length y * bif b then 1 else 0) +     (↑(List.foldl addLsb 0
          (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).snd) -       2 ^ List.length x *         bif (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).fst then 1
        else 0)
x, y: List Bool

h: List.length x = List.length y

true.false
(↑(2 ^             List.length
              (xor (xor true false)
                  (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).fst ::                 (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).snd) *           0 +         ((2 ^               List.length
                (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).snd *             bif
                xor (xor true false)
                  (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).fst then
              1
            else 0) +           List.foldl addLsb 0
            (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).snd)) -     2 ^ List.length (true :: x) *       bif
          !true && false ||               !true && (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).fst ||             false && (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).fst then
        1
      else 0) =   ↑(2 ^ List.length x * bif true then 1 else 0) + -↑(2 ^ List.length y * bif false then 1 else 0) +     (↑(List.foldl addLsb 0
          (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).snd) -       2 ^ List.length x *         bif (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).fst then 1
        else 0)
x, y: List Bool

h: List.length x = List.length y

true.true
(↑(2 ^             List.length
              (xor (xor true true)
                  (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).fst ::                 (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).snd) *           0 +         ((2 ^               List.length
                (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).snd *             bif
                xor (xor true true)
                  (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).fst then
              1
            else 0) +           List.foldl addLsb 0
            (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).snd)) -     2 ^ List.length (true :: x) *       bif
          !true && true ||               !true && (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).fst ||             true && (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).fst then
        1
      else 0) =   ↑(2 ^ List.length x * bif true then 1 else 0) + -↑(2 ^ List.length y * bif true then 1 else 0) +     (↑(List.foldl addLsb 0
          (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).snd) -       2 ^ List.length x *         bif (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).fst then 1
        else 0)
a: Bool

x: List Bool

b: Bool

y: List Bool

h: List.length x = List.length y

(↑(2 ^             List.length
              (xor (xor a b)
                  (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).fst ::                 (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).snd) *           0 +         ((2 ^               List.length
                (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).snd *             bif
                xor (xor a b)
                  (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).fst then
              1
            else 0) +           List.foldl addLsb 0
            (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).snd)) -     2 ^ List.length (a :: x) *       bif
          !a && b ||               !a && (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).fst ||             b && (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).fst then
        1
      else 0) =   ↑(2 ^ List.length x * bif a then 1 else 0) + -↑(2 ^ List.length y * bif b then 1 else 0) +     (↑(List.foldl addLsb 0
          (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).snd) -       2 ^ List.length x *         bif (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).fst then 1
        else 0)
x, y: List Bool

h: List.length x = List.length y

false.false
(↑(2 ^             List.length
              (xor (xor false false)
                  (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).fst ::                 (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).snd) *           0 +         ((2 ^               List.length
                (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).snd *             bif
                xor (xor false false)
                  (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).fst then
              1
            else 0) +           List.foldl addLsb 0
            (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).snd)) -     2 ^ List.length (false :: x) *       bif
          !false && false ||               !false &&                 (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).fst ||             false && (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).fst then
        1
      else 0) =   ↑(2 ^ List.length x * bif false then 1 else 0) + -↑(2 ^ List.length y * bif false then 1 else 0) +     (↑(List.foldl addLsb 0
          (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).snd) -       2 ^ List.length x *         bif (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).fst then 1
        else 0)
x, y: List Bool

h: List.length x = List.length y

false.true
(↑(2 ^             List.length
              (xor (xor false true)
                  (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).fst ::                 (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).snd) *           0 +         ((2 ^               List.length
                (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).snd *             bif
                xor (xor false true)
                  (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).fst then
              1
            else 0) +           List.foldl addLsb 0
            (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).snd)) -     2 ^ List.length (false :: x) *       bif
          !false && true ||               !false &&                 (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).fst ||             true && (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).fst then
        1
      else 0) =   ↑(2 ^ List.length x * bif false then 1 else 0) + -↑(2 ^ List.length y * bif true then 1 else 0) +     (↑(List.foldl addLsb 0
          (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).snd) -       2 ^ List.length x *         bif (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).fst then 1
        else 0)
x, y: List Bool

h: List.length x = List.length y

true.false
(↑(2 ^             List.length
              (xor (xor true false)
                  (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).fst ::                 (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).snd) *           0 +         ((2 ^               List.length
                (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).snd *             bif
                xor (xor true false)
                  (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).fst then
              1
            else 0) +           List.foldl addLsb 0
            (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).snd)) -     2 ^ List.length (true :: x) *       bif
          !true && false ||               !true && (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).fst ||             false && (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).fst then
        1
      else 0) =   ↑(2 ^ List.length x * bif true then 1 else 0) + -↑(2 ^ List.length y * bif false then 1 else 0) +     (↑(List.foldl addLsb 0
          (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).snd) -       2 ^ List.length x *         bif (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).fst then 1
        else 0)
x, y: List Bool

h: List.length x = List.length y

true.true
(↑(2 ^             List.length
              (xor (xor true true)
                  (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).fst ::                 (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).snd) *           0 +         ((2 ^               List.length
                (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).snd *             bif
                xor (xor true true)
                  (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).fst then
              1
            else 0) +           List.foldl addLsb 0
            (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).snd)) -     2 ^ List.length (true :: x) *       bif
          !true && true ||               !true && (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).fst ||             true && (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).fst then
        1
      else 0) =   ↑(2 ^ List.length x * bif true then 1 else 0) + -↑(2 ^ List.length y * bif true then 1 else 0) +     (↑(List.foldl addLsb 0
          (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).snd) -       2 ^ List.length x *         bif (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).fst then 1
        else 0)
a: Bool

x: List Bool

b: Bool

y: List Bool

h: List.length x = List.length y

(↑(2 ^             List.length
              (xor (xor a b)
                  (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).fst ::                 (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).snd) *           0 +         ((2 ^               List.length
                (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).snd *             bif
                xor (xor a b)
                  (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).fst then
              1
            else 0) +           List.foldl addLsb 0
            (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).snd)) -     2 ^ List.length (a :: x) *       bif
          !a && b ||               !a && (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).fst ||             b && (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).fst then
        1
      else 0) =   ↑(2 ^ List.length x * bif a then 1 else 0) + -↑(2 ^ List.length y * bif b then 1 else 0) +     (↑(List.foldl addLsb 0
          (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).snd) -       2 ^ List.length x *         bif (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).fst then 1
        else 0)
x, y: List Bool

h: List.length x = List.length y

true.true
↑2 ^ List.length y *       ↑(bif (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor x (xor y c))) x y false).fst then 1
        else 0) +     (↑(List.foldl addLsb 0
          (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor x (xor y c))) x y false).snd) +       -((2 ^ List.length y *             bif (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor x (xor y c))) x y false).fst then 1
            else 0) +           2 ^ List.length y *             bif (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor x (xor y c))) x y false).fst then 1
            else 0)) =   ↑2 ^ List.length y +     (-↑2 ^ List.length y +       (↑(List.foldl addLsb 0
            (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor x (xor y c))) x y false).snd) +         -(2 ^ List.length y *             bif (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor x (xor y c))) x y false).fst then 1
            else 0)))
a: Bool

x: List Bool

b: Bool

y: List Bool

h: List.length x = List.length y

(↑(2 ^             List.length
              (xor (xor a b)
                  (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).fst ::                 (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).snd) *           0 +         ((2 ^               List.length
                (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).snd *             bif
                xor (xor a b)
                  (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).fst then
              1
            else 0) +           List.foldl addLsb 0
            (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).snd)) -     2 ^ List.length (a :: x) *       bif
          !a && b ||               !a && (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).fst ||             b && (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).fst then
        1
      else 0) =   ↑(2 ^ List.length x * bif a then 1 else 0) + -↑(2 ^ List.length y * bif b then 1 else 0) +     (↑(List.foldl addLsb 0
          (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).snd) -       2 ^ List.length x *         bif (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).fst then 1
        else 0)
x, y: List Bool

h: List.length x = List.length y

false.false
↑2 ^ List.length y *       ↑(bif (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor x (xor y c))) x y false).fst then 1
        else 0) +     (↑(List.foldl addLsb 0
          (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor x (xor y c))) x y false).snd) +       -((2 ^ List.length y *             bif (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor x (xor y c))) x y false).fst then 1
            else 0) +           2 ^ List.length y *             bif (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor x (xor y c))) x y false).fst then 1
            else 0)) =   ↑(List.foldl addLsb 0
        (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor x (xor y c))) x y false).snd) +     -(2 ^ List.length y *         bif (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor x (xor y c))) x y false).fst then 1
        else 0)
x, y: List Bool

h: List.length x = List.length y

false.true
-(2 ^ List.length y + 2 ^ List.length y) +     (↑2 ^ List.length y *         ↑(bif (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor x (xor y c))) x y false).fst then 0
          else 1) +       ↑(List.foldl addLsb 0
          (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor x (xor y c))) x y false).snd)) =   -↑2 ^ List.length y +     (↑(List.foldl addLsb 0
          (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor x (xor y c))) x y false).snd) +       -(2 ^ List.length y *           bif (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor x (xor y c))) x y false).fst then 1
          else 0))
x, y: List Bool

h: List.length x = List.length y

true.false
↑2 ^ List.length y *       ↑(bif (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor x (xor y c))) x y false).fst then 0
        else 1) +     ↑(List.foldl addLsb 0
        (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor x (xor y c))) x y false).snd) =   ↑2 ^ List.length y +     (↑(List.foldl addLsb 0
          (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor x (xor y c))) x y false).snd) +       -(2 ^ List.length y *           bif (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor x (xor y c))) x y false).fst then 1
          else 0))
x, y: List Bool

h: List.length x = List.length y

true.true
↑2 ^ List.length y *       ↑(bif (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor x (xor y c))) x y false).fst then 1
        else 0) +     (↑(List.foldl addLsb 0
          (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor x (xor y c))) x y false).snd) +       -((2 ^ List.length y *             bif (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor x (xor y c))) x y false).fst then 1
            else 0) +           2 ^ List.length y *             bif (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor x (xor y c))) x y false).fst then 1
            else 0)) =   ↑2 ^ List.length y +     (-↑2 ^ List.length y +       (↑(List.foldl addLsb 0
            (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor x (xor y c))) x y false).snd) +         -(2 ^ List.length y *             bif (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor x (xor y c))) x y false).fst then 1
            else 0)))
a: Bool

x: List Bool

b: Bool

y: List Bool

h: List.length x = List.length y

(↑(2 ^             List.length
              (xor (xor a b)
                  (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).fst ::                 (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).snd) *           0 +         ((2 ^               List.length
                (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).snd *             bif
                xor (xor a b)
                  (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).fst then
              1
            else 0) +           List.foldl addLsb 0
            (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).snd)) -     2 ^ List.length (a :: x) *       bif
          !a && b ||               !a && (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).fst ||             b && (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).fst then
        1
      else 0) =   ↑(2 ^ List.length x * bif a then 1 else 0) + -↑(2 ^ List.length y * bif b then 1 else 0) +     (↑(List.foldl addLsb 0
          (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).snd) -       2 ^ List.length x *         bif (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).fst then 1
        else 0)
x, y: List Bool

h: List.length x = List.length y

true.false
↑(bif (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor x (xor y c))) x y false).fst then 0 else 1) *       2 ^ List.length y +     ↑(List.foldl addLsb 0
        (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor x (xor y c))) x y false).snd) =   ↑(List.foldl addLsb 0
          (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor x (xor y c))) x y false).snd) -       (bif (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor x (xor y c))) x y false).fst then 1
        else 0) *         2 ^ List.length y +     2 ^ List.length y
a: Bool

x: List Bool

b: Bool

y: List Bool

h: List.length x = List.length y

(↑(2 ^             List.length
              (xor (xor a b)
                  (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).fst ::                 (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).snd) *           0 +         ((2 ^               List.length
                (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).snd *             bif
                xor (xor a b)
                  (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).fst then
              1
            else 0) +           List.foldl addLsb 0
            (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).snd)) -     2 ^ List.length (a :: x) *       bif
          !a && b ||               !a && (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).fst ||             b && (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).fst then
        1
      else 0) =   ↑(2 ^ List.length x * bif a then 1 else 0) + -↑(2 ^ List.length y * bif b then 1 else 0) +     (↑(List.foldl addLsb 0
          (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).snd) -       2 ^ List.length x *         bif (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).fst then 1
        else 0)
x, y: List Bool

h: List.length x = List.length y

false.false
↑(bif (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor x (xor y c))) x y false).fst then 1 else 0) *       2 ^ List.length y +     (↑(List.foldl addLsb 0
          (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor x (xor y c))) x y false).snd) -       (bif (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor x (xor y c))) x y false).fst then 1
          else 0) *           2 ^ List.length y *         2) =   ↑(List.foldl addLsb 0
        (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor x (xor y c))) x y false).snd) -     (bif (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor x (xor y c))) x y false).fst then 1 else 0) *       2 ^ List.length y
x, y: List Bool

h: List.length x = List.length y

false.true
↑(bif (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor x (xor y c))) x y false).fst then 0 else 1) *       2 ^ List.length y +     (↑(List.foldl addLsb 0
          (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor x (xor y c))) x y false).snd) -       2 ^ List.length y * 2) =   ↑(List.foldl addLsb 0
        (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor x (xor y c))) x y false).snd) +     (-((bif (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor x (xor y c))) x y false).fst then 1
          else 0) *           2 ^ List.length y) -       2 ^ List.length y)
x, y: List Bool

h: List.length x = List.length y

true.false
↑(bif (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor x (xor y c))) x y false).fst then 0 else 1) *       2 ^ List.length y +     ↑(List.foldl addLsb 0
        (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor x (xor y c))) x y false).snd) =   ↑(List.foldl addLsb 0
          (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor x (xor y c))) x y false).snd) -       (bif (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor x (xor y c))) x y false).fst then 1
        else 0) *         2 ^ List.length y +     2 ^ List.length y
x, y: List Bool

h: List.length x = List.length y

true.true
↑(bif (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor x (xor y c))) x y false).fst then 1 else 0) *       2 ^ List.length y +     (↑(List.foldl addLsb 0
          (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor x (xor y c))) x y false).snd) -       (bif (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor x (xor y c))) x y false).fst then 1
          else 0) *           2 ^ List.length y *         2) =   ↑(List.foldl addLsb 0
        (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor x (xor y c))) x y false).snd) -     (bif (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor x (xor y c))) x y false).fst then 1 else 0) *       2 ^ List.length y
a: Bool

x: List Bool

b: Bool

y: List Bool

h: List.length x = List.length y

(↑(2 ^             List.length
              (xor (xor a b)
                  (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).fst ::                 (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).snd) *           0 +         ((2 ^               List.length
                (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).snd *             bif
                xor (xor a b)
                  (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).fst then
              1
            else 0) +           List.foldl addLsb 0
            (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).snd)) -     2 ^ List.length (a :: x) *       bif
          !a && b ||               !a && (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).fst ||             b && (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).fst then
        1
      else 0) =   ↑(2 ^ List.length x * bif a then 1 else 0) + -↑(2 ^ List.length y * bif b then 1 else 0) +     (↑(List.foldl addLsb 0
          (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).snd) -       2 ^ List.length x *         bif (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).fst then 1
        else 0)
x, y: List Bool

h: List.length x = List.length y

true.true.false
↑(bif false then 1 else 0) * 2 ^ List.length y +     (↑(List.foldl addLsb 0
          (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor x (xor y c))) x y false).snd) -       (bif false then 1 else 0) * 2 ^ List.length y * 2) =   ↑(List.foldl addLsb 0
        (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor x (xor y c))) x y false).snd) -     (bif false then 1 else 0) * 2 ^ List.length y
x, y: List Bool

h: List.length x = List.length y

true.true.true
↑(bif true then 1 else 0) * 2 ^ List.length y +     (↑(List.foldl addLsb 0
          (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor x (xor y c))) x y false).snd) -       (bif true then 1 else 0) * 2 ^ List.length y * 2) =   ↑(List.foldl addLsb 0
        (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor x (xor y c))) x y false).snd) -     (bif true then 1 else 0) * 2 ^ List.length y
a: Bool

x: List Bool

b: Bool

y: List Bool

h: List.length x = List.length y

(↑(2 ^             List.length
              (xor (xor a b)
                  (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).fst ::                 (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).snd) *           0 +         ((2 ^               List.length
                (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).snd *             bif
                xor (xor a b)
                  (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).fst then
              1
            else 0) +           List.foldl addLsb 0
            (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).snd)) -     2 ^ List.length (a :: x) *       bif
          !a && b ||               !a && (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).fst ||             b && (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).fst then
        1
      else 0) =   ↑(2 ^ List.length x * bif a then 1 else 0) + -↑(2 ^ List.length y * bif b then 1 else 0) +     (↑(List.foldl addLsb 0
          (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).snd) -       2 ^ List.length x *         bif (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).fst then 1
        else 0)
x, y: List Bool

h: List.length x = List.length y

false.false.false
↑(bif false then 1 else 0) * 2 ^ List.length y +     (↑(List.foldl addLsb 0
          (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor x (xor y c))) x y false).snd) -       (bif false then 1 else 0) * 2 ^ List.length y * 2) =   ↑(List.foldl addLsb 0
        (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor x (xor y c))) x y false).snd) -     (bif false then 1 else 0) * 2 ^ List.length y
x, y: List Bool

h: List.length x = List.length y

false.false.true
↑(bif true then 1 else 0) * 2 ^ List.length y +     (↑(List.foldl addLsb 0
          (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor x (xor y c))) x y false).snd) -       (bif true then 1 else 0) * 2 ^ List.length y * 2) =   ↑(List.foldl addLsb 0
        (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor x (xor y c))) x y false).snd) -     (bif true then 1 else 0) * 2 ^ List.length y
x, y: List Bool

h: List.length x = List.length y

false.true.false
↑(bif false then 0 else 1) * 2 ^ List.length y +     (↑(List.foldl addLsb 0
          (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor x (xor y c))) x y false).snd) -       2 ^ List.length y * 2) =   ↑(List.foldl addLsb 0
        (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor x (xor y c))) x y false).snd) +     (-((bif false then 1 else 0) * 2 ^ List.length y) - 2 ^ List.length y)
x, y: List Bool

h: List.length x = List.length y

false.true.true
↑(bif true then 0 else 1) * 2 ^ List.length y +     (↑(List.foldl addLsb 0
          (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor x (xor y c))) x y false).snd) -       2 ^ List.length y * 2) =   ↑(List.foldl addLsb 0
        (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor x (xor y c))) x y false).snd) +     (-((bif true then 1 else 0) * 2 ^ List.length y) - 2 ^ List.length y)
x, y: List Bool

h: List.length x = List.length y

true.false.false
↑(bif false then 0 else 1) * 2 ^ List.length y +     ↑(List.foldl addLsb 0
        (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor x (xor y c))) x y false).snd) =   ↑(List.foldl addLsb 0
          (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor x (xor y c))) x y false).snd) -       (bif false then 1 else 0) * 2 ^ List.length y +     2 ^ List.length y
x, y: List Bool

h: List.length x = List.length y

true.false.true
↑(bif true then 0 else 1) * 2 ^ List.length y +     ↑(List.foldl addLsb 0
        (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor x (xor y c))) x y false).snd) =   ↑(List.foldl addLsb 0
          (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor x (xor y c))) x y false).snd) -       (bif true then 1 else 0) * 2 ^ List.length y +     2 ^ List.length y
x, y: List Bool

h: List.length x = List.length y

true.true.false
↑(bif false then 1 else 0) * 2 ^ List.length y +     (↑(List.foldl addLsb 0
          (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor x (xor y c))) x y false).snd) -       (bif false then 1 else 0) * 2 ^ List.length y * 2) =   ↑(List.foldl addLsb 0
        (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor x (xor y c))) x y false).snd) -     (bif false then 1 else 0) * 2 ^ List.length y
x, y: List Bool

h: List.length x = List.length y

true.true.true
↑(bif true then 1 else 0) * 2 ^ List.length y +     (↑(List.foldl addLsb 0
          (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor x (xor y c))) x y false).snd) -       (bif true then 1 else 0) * 2 ^ List.length y * 2) =   ↑(List.foldl addLsb 0
        (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor x (xor y c))) x y false).snd) -     (bif true then 1 else 0) * 2 ^ List.length y
a: Bool

x: List Bool

b: Bool

y: List Bool

h: List.length x = List.length y

(↑(2 ^             List.length
              (xor (xor a b)
                  (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).fst ::                 (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).snd) *           0 +         ((2 ^               List.length
                (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).snd *             bif
                xor (xor a b)
                  (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).fst then
              1
            else 0) +           List.foldl addLsb 0
            (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).snd)) -     2 ^ List.length (a :: x) *       bif
          !a && b ||               !a && (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).fst ||             b && (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).fst then
        1
      else 0) =   ↑(2 ^ List.length x * bif a then 1 else 0) + -↑(2 ^ List.length y * bif b then 1 else 0) +     (↑(List.foldl addLsb 0
          (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).snd) -       2 ^ List.length x *         bif (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).fst then 1
        else 0)
x, y: List Bool

h: List.length x = List.length y

true.true.true
2 ^ List.length y +     (↑(List.foldl addLsb 0
          (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor x (xor y c))) x y false).snd) -       2 ^ List.length y * 2) =   ↑(List.foldl addLsb 0
        (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor x (xor y c))) x y false).snd) -     2 ^ List.length y
a: Bool

x: List Bool

b: Bool

y: List Bool

h: List.length x = List.length y

(↑(2 ^             List.length
              (xor (xor a b)
                  (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).fst ::                 (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).snd) *           0 +         ((2 ^               List.length
                (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).snd *             bif
                xor (xor a b)
                  (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).fst then
              1
            else 0) +           List.foldl addLsb 0
            (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).snd)) -     2 ^ List.length (a :: x) *       bif
          !a && b ||               !a && (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).fst ||             b && (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).fst then
        1
      else 0) =   ↑(2 ^ List.length x * bif a then 1 else 0) + -↑(2 ^ List.length y * bif b then 1 else 0) +     (↑(List.foldl addLsb 0
          (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).snd) -       2 ^ List.length x *         bif (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).fst then 1
        else 0)
x, y: List Bool

h: List.length x = List.length y

false.false.true
2 ^ List.length y +     (↑(List.foldl addLsb 0
          (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor x (xor y c))) x y false).snd) -       2 ^ List.length y * 2) =   ↑(List.foldl addLsb 0
        (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor x (xor y c))) x y false).snd) -     2 ^ List.length y
x, y: List Bool

h: List.length x = List.length y

false.true.false
2 ^ List.length y +     (↑(List.foldl addLsb 0
          (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor x (xor y c))) x y false).snd) -       2 ^ List.length y * 2) =   ↑(List.foldl addLsb 0
        (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor x (xor y c))) x y false).snd) +     -2 ^ List.length y
x, y: List Bool

h: List.length x = List.length y

false.true.true
↑(List.foldl addLsb 0 (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor x (xor y c))) x y false).snd) -     2 ^ List.length y * 2 =   ↑(List.foldl addLsb 0
        (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor x (xor y c))) x y false).snd) +     (-2 ^ List.length y - 2 ^ List.length y)
x, y: List Bool

h: List.length x = List.length y

true.false.false
2 ^ List.length y +     ↑(List.foldl addLsb 0
        (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor x (xor y c))) x y false).snd) =   ↑(List.foldl addLsb 0
        (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor x (xor y c))) x y false).snd) +     2 ^ List.length y
x, y: List Bool

h: List.length x = List.length y

true.true.true
2 ^ List.length y +     (↑(List.foldl addLsb 0
          (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor x (xor y c))) x y false).snd) -       2 ^ List.length y * 2) =   ↑(List.foldl addLsb 0
        (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor x (xor y c))) x y false).snd) -     2 ^ List.length y
a: Bool

x: List Bool

b: Bool

y: List Bool

h: List.length x = List.length y

(↑(2 ^             List.length
              (xor (xor a b)
                  (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).fst ::                 (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).snd) *           0 +         ((2 ^               List.length
                (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).snd *             bif
                xor (xor a b)
                  (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).fst then
              1
            else 0) +           List.foldl addLsb 0
            (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).snd)) -     2 ^ List.length (a :: x) *       bif
          !a && b ||               !a && (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).fst ||             b && (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).fst then
        1
      else 0) =   ↑(2 ^ List.length x * bif a then 1 else 0) + -↑(2 ^ List.length y * bif b then 1 else 0) +     (↑(List.foldl addLsb 0
          (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).snd) -       2 ^ List.length x *         bif (List.mapAccumrβ‚‚ (fun x y c => (!x && y || !x && c || y && c, xor (xor x y) c)) x y false).fst then 1
        else 0)
Goals accomplished! πŸ™



instance: βˆ€ (n : β„•), NeZero (2 ^ n)
instance (
n: β„•
n : 
β„•: Type
β„•) : 
NeZero: {R : Type ?u.190440} β†’ [inst : Zero R] β†’ R β†’ Prop
NeZero (
2: ?m.190522
2 ^ 
n: β„•
n) := ⟨
Nat.pos_iff_ne_zero: βˆ€ {n : β„•}, 0 < n ↔ n β‰  0
Nat.pos_iff_ne_zero.
1: βˆ€ {a b : Prop}, (a ↔ b) β†’ a β†’ b
1 <| 
pow_pos: βˆ€ {Ξ± : Type ?u.190698} [inst : StrictOrderedSemiring Ξ±] {a : Ξ±}, 0 < a β†’ βˆ€ (n : β„•), 0 < a ^ n
pow_pos (
Goals accomplished! πŸ™
n: β„•

0 < 2
Goals accomplished! πŸ™
) 
_: β„•
_⟩

theorem 
toZMod_sbb: βˆ€ {n : β„•} (x y : Bitvec n), toZMod (sbb x y false).snd = toZMod x - toZMod y
toZMod_sbb {
n: β„•
n : 
β„•: Type
β„•} (
x: Bitvec n
x 
y: Bitvec n
y : 
Bitvec: β„• β†’ Type
Bitvec 
n: β„•
n) : (
x: Bitvec n
x.
sbb: {n : β„•} β†’ Bitvec n β†’ Bitvec n β†’ Bool β†’ Bool Γ— Bitvec n
sbb 
y: Bitvec n
y 
false: Bool
false).
2: {Ξ± : Type ?u.190815} β†’ {Ξ² : Type ?u.190814} β†’ Ξ± Γ— Ξ² β†’ Ξ²
2.
toZMod: {n : β„•} β†’ Bitvec n β†’ ZMod (2 ^ n)
toZMod = 
x: Bitvec n
x.
toZMod: {n : β„•} β†’ Bitvec n β†’ ZMod (2 ^ n)
toZMod - 
y: Bitvec n
y.
toZMod: {n : β„•} β†’ Bitvec n β†’ ZMod (2 ^ n)
toZMod := 
Goals accomplished! πŸ™
n: β„•

x, y: Bitvec n

toZMod (sbb x y false).snd = toZMod x - toZMod y
n: β„•

y: Bitvec n

x: List Bool

hx: List.length x = n

mk
toZMod (sbb { val := x, property := hx } y false).snd = toZMod { val := x, property := hx } - toZMod y
n: β„•

x, y: Bitvec n

toZMod (sbb x y false).snd = toZMod x - toZMod y
n: β„•

x: List Bool

hx: List.length x = n

y: List Bool

hy: List.length y = n

mk.mk
toZMod (sbb { val := x, property := hx } { val := y, property := hy } false).snd =   toZMod { val := x, property := hx } - toZMod { val := y, property := hy }
n: β„•

x, y: Bitvec n

toZMod (sbb x y false).snd = toZMod x - toZMod y
n: β„•

x: List Bool

hx: List.length x = n

y: List Bool

hy: List.length y = n

mk.mk
↑(List.foldl addLsb 0 (List.mapAccumrβ‚‚ (fun x y c => (Bitvec.carry (!x) y c, Bitvec.xor3 x y c)) x y false).snd) =   ↑(List.foldl addLsb 0 x) - ↑(List.foldl addLsb 0 y)
n: β„•

x, y: Bitvec n

toZMod (sbb x y false).snd = toZMod x - toZMod y
n: β„•

x: List Bool

hx: List.length x = n

y: List Bool

hy: List.length y = n

mk.mk
↑(List.foldl addLsb 0 (List.mapAccumrβ‚‚ (fun x y c => (Bitvec.carry (!x) y c, Bitvec.xor3 x y c)) x y false).snd) =   ↑(List.foldl addLsb 0 x) - ↑(List.foldl addLsb 0 y)
Goals accomplished! πŸ™
n: β„•

x: List Bool

hx: List.length x = n

y: List Bool

hy: List.length y = n

2 ^ n = 0
n: β„•

x: List Bool

hx: List.length x = n

y: List Bool

hy: List.length y = n

2 ^ n = 0
n: β„•

x: List Bool

hx: List.length x = n

y: List Bool

hy: List.length y = n

↑2 ^ n = 0
n: β„•

x: List Bool

hx: List.length x = n

y: List Bool

hy: List.length y = n

2 ^ n = 0
n: β„•

x: List Bool

hx: List.length x = n

y: List Bool

hy: List.length y = n

↑(2 ^ n) = 0
n: β„•

x: List Bool

hx: List.length x = n

y: List Bool

hy: List.length y = n

2 ^ n = 0
n: β„•

x: List Bool

hx: List.length x = n

y: List Bool

hy: List.length y = n

0 = 0
Goals accomplished! πŸ™
n: β„•

x, y: Bitvec n

toZMod (sbb x y false).snd = toZMod x - toZMod y
n: β„•

x: List Bool

hx: List.length x = n

y: List Bool

hy: List.length y = n

h2n: 2 ^ n = 0

this: ↑(↑(List.foldl addLsb 0 (List.mapAccumrβ‚‚ (fun x y c => (Bitvec.carry (!x) y c, Bitvec.xor3 x y c)) x y false).snd) -       2 ^ List.length x *         bif (List.mapAccumrβ‚‚ (fun x y c => (Bitvec.carry (!x) y c, Bitvec.xor3 x y c)) x y false).fst then 1 else 0) =   ↑(↑(List.foldl addLsb 0 x) + -↑(List.foldl addLsb 0 y))

mk.mk
↑(List.foldl addLsb 0 (List.mapAccumrβ‚‚ (fun x y c => (Bitvec.carry (!x) y c, Bitvec.xor3 x y c)) x y false).snd) =   ↑(List.foldl addLsb 0 x) - ↑(List.foldl addLsb 0 y)
n: β„•

x, y: Bitvec n

toZMod (sbb x y false).snd = toZMod x - toZMod y
Goals accomplished! πŸ™


theorem 
toZMod_sub: βˆ€ {n : β„•} (x y : Bitvec n), toZMod (x - y) = toZMod x - toZMod y
toZMod_sub {
n: β„•
n : 
β„•: Type
β„•} (
x: Bitvec n
x 
y: Bitvec n
y : 
Bitvec: β„• β†’ Type
Bitvec 
n: β„•
n) : (
x: Bitvec n
x - 
y: Bitvec n
y).
toZMod: {n : β„•} β†’ Bitvec n β†’ ZMod (2 ^ n)
toZMod = 
x: Bitvec n
x.
toZMod: {n : β„•} β†’ Bitvec n β†’ ZMod (2 ^ n)
toZMod - 
y: Bitvec n
y.
toZMod: {n : β„•} β†’ Bitvec n β†’ ZMod (2 ^ n)
toZMod :=
  
toZMod_sbb: βˆ€ {n : β„•} (x y : Bitvec n), toZMod (sbb x y false).snd = toZMod x - toZMod y
toZMod_sbb 
x: Bitvec n
x 
y: Bitvec n
y

theorem 
toInt_neg_aux: βˆ€ (x : List Bool),
  (↑(List.foldl addLsb 0 (List.mapAccumr (fun y c => (y || c, xor y c)) x false).snd) -       2 ^ List.length x * bif (List.mapAccumr (fun y c => (y || c, xor y c)) x false).fst then 1 else 0) =     -↑(List.foldl addLsb 0 x)
toInt_neg_aux : βˆ€ (
x: List Bool
x : 
List: Type ?u.199365 β†’ Type ?u.199365
List 
Bool: Type
Bool),
    ((
List.foldl: {Ξ± : Type ?u.199375} β†’ {Ξ² : Type ?u.199374} β†’ (Ξ± β†’ Ξ² β†’ Ξ±) β†’ Ξ± β†’ List Ξ² β†’ Ξ±
List.foldl 
addLsb: β„• β†’ Bool β†’ β„•
addLsb (
0: ?m.199386
0 : 
β„•: Type
β„•) (
List.mapAccumr: {Οƒ : Type ?u.199398} β†’ {Ξ± : Type ?u.199397} β†’ {Ξ² : Type ?u.199396} β†’ (Ξ± β†’ Οƒ β†’ Οƒ Γ— Ξ²) β†’ List Ξ± β†’ Οƒ β†’ Οƒ Γ— List Ξ²
List.mapAccumr (fun 
y: ?m.199403
y 
c: ?m.199406
c => (
y: ?m.199403
y || 
c: ?m.199406
c, 
xor: Bool β†’ Bool β†’ Bool
xor 
y: ?m.199403
y 
c: ?m.199406
c)) 
x: List Bool
x 
false: Bool
false).
snd: {Ξ± : Type ?u.199424} β†’ {Ξ² : Type ?u.199423} β†’ Ξ± Γ— Ξ² β†’ Ξ²
snd : 
β„•: Type
β„•) 
      - 
2: ?m.199434
2 ^ 
x: List Bool
x.
length: {Ξ± : Type ?u.199443} β†’ List Ξ± β†’ β„•
length * 
cond: {Ξ± : Type ?u.199447} β†’ Bool β†’ Ξ± β†’ Ξ± β†’ Ξ±
cond (
List.mapAccumr: {Οƒ : Type ?u.199451} β†’ {Ξ± : Type ?u.199450} β†’ {Ξ² : Type ?u.199449} β†’ (Ξ± β†’ Οƒ β†’ Οƒ Γ— Ξ²) β†’ List Ξ± β†’ Οƒ β†’ Οƒ Γ— List Ξ²
List.mapAccumr (fun 
y: ?m.199456
y 
c: ?m.199459
c => (
y: ?m.199456
y || 
c: ?m.199459
c, 
xor: Bool β†’ Bool β†’ Bool
xor 
y: ?m.199456
y 
c: ?m.199459
c)) 
x: List Bool
x 
false: Bool
false).
fst: {Ξ± : Type ?u.199474} β†’ {Ξ² : Type ?u.199473} β†’ Ξ± Γ— Ξ² β†’ Ξ±
fst 
1: ?m.199478
1 
0: ?m.199488
0 : 
β„€: Type
β„€) = 
      -(
List.foldl: {Ξ± : Type ?u.199881} β†’ {Ξ² : Type ?u.199880} β†’ (Ξ± β†’ Ξ² β†’ Ξ±) β†’ Ξ± β†’ List Ξ² β†’ Ξ±
List.foldl 
addLsb: β„• β†’ Bool β†’ β„•
addLsb 
0: ?m.199891
0 
x: List Bool
x)
  | [] => 
rfl: βˆ€ {Ξ± : Sort ?u.200249} {a : Ξ±}, a = a
rfl
  | 
a: Bool
a::
x: List Bool
x => 
Goals accomplished! πŸ™
a: Bool

x: List Bool

(↑(List.foldl addLsb 0 (List.mapAccumr (fun y c => (y || c, xor y c)) (a :: x) false).snd) -     2 ^ List.length (a :: x) * bif (List.mapAccumr (fun y c => (y || c, xor y c)) (a :: x) false).fst then 1 else 0) =   -↑(List.foldl addLsb 0 (a :: x))
a: Bool

x: List Bool

(↑(List.foldl addLsb 0
        (xor a (List.mapAccumr (fun y c => (y || c, xor y c)) x false).fst ::           (List.mapAccumr (fun y c => (y || c, xor y c)) x false).snd)) -     2 ^ List.length (a :: x) * bif a || (List.mapAccumr (fun y c => (y || c, xor y c)) x false).fst then 1 else 0) =   -↑(List.foldl addLsb 0 (a :: x))
a: Bool

x: List Bool

(↑(List.foldl addLsb 0 (List.mapAccumr (fun y c => (y || c, xor y c)) (a :: x) false).snd) -     2 ^ List.length (a :: x) * bif (List.mapAccumr (fun y c => (y || c, xor y c)) (a :: x) false).fst then 1 else 0) =   -↑(List.foldl addLsb 0 (a :: x))
a: Bool

x: List Bool

(↑(List.foldl addLsb 0
        (xor a (List.mapAccumr (fun y c => (y || c, xor y c)) x false).fst ::           (List.mapAccumr (fun y c => (y || c, xor y c)) x false).snd)) -     2 ^ List.length (a :: x) * bif a || (List.mapAccumr (fun y c => (y || c, xor y c)) x false).fst then 1 else 0) =   -↑(List.foldl addLsb 0 (a :: x))
a: Bool

x: List Bool

(↑((2 ^ List.length (List.mapAccumr (fun y c => (y || c, xor y c)) x false).snd *           bif xor a (List.mapAccumr (fun y c => (y || c, xor y c)) x false).fst then 1 else 0) +         List.foldl addLsb 0 (List.mapAccumr (fun y c => (y || c, xor y c)) x false).snd) -     2 ^ List.length (a :: x) * bif a || (List.mapAccumr (fun y c => (y || c, xor y c)) x false).fst then 1 else 0) =   -↑(List.foldl addLsb 0 (a :: x))
a: Bool

x: List Bool

(↑(List.foldl addLsb 0
        (xor a (List.mapAccumr (fun y c => (y || c, xor y c)) x false).fst ::           (List.mapAccumr (fun y c => (y || c, xor y c)) x false).snd)) -     2 ^ List.length (a :: x) * bif a || (List.mapAccumr (fun y c => (y || c, xor y c)) x false).fst then 1 else 0) =   -↑(List.foldl addLsb 0 (a :: x))
a: Bool

x: List Bool

(↑((2 ^ List.length (List.mapAccumr (fun y c => (y || c, xor y c)) x false).snd *           bif xor a (List.mapAccumr (fun y c => (y || c, xor y c)) x false).fst then 1 else 0) +         List.foldl addLsb 0 (List.mapAccumr (fun y c => (y || c, xor y c)) x false).snd) -     2 ^ List.length (a :: x) * bif a || (List.mapAccumr (fun y c => (y || c, xor y c)) x false).fst then 1 else 0) =   -↑((2 ^ List.length x * bif a then 1 else 0) + List.foldl addLsb 0 x)
a: Bool

x: List Bool

(↑(List.foldl addLsb 0
        (xor a (List.mapAccumr (fun y c => (y || c, xor y c)) x false).fst ::           (List.mapAccumr (fun y c => (y || c, xor y c)) x false).snd)) -     2 ^ List.length (a :: x) * bif a || (List.mapAccumr (fun y c => (y || c, xor y c)) x false).fst then 1 else 0) =   -↑(List.foldl addLsb 0 (a :: x))
a: Bool

x: List Bool

(↑(2 ^ List.length (List.mapAccumr (fun y c => (y || c, xor y c)) x false).snd *           bif xor a (List.mapAccumr (fun y c => (y || c, xor y c)) x false).fst then 1 else 0) +       ↑(List.foldl addLsb 0 (List.mapAccumr (fun y c => (y || c, xor y c)) x false).snd) -     2 ^ List.length (a :: x) * bif a || (List.mapAccumr (fun y c => (y || c, xor y c)) x false).fst then 1 else 0) =   -↑((2 ^ List.length x * bif a then 1 else 0) + List.foldl addLsb 0 x)
a: Bool

x: List Bool

(↑(List.foldl addLsb 0
        (xor a (List.mapAccumr (fun y c => (y || c, xor y c)) x false).fst ::           (List.mapAccumr (fun y c => (y || c, xor y c)) x false).snd)) -     2 ^ List.length (a :: x) * bif a || (List.mapAccumr (fun y c => (y || c, xor y c)) x false).fst then 1 else 0) =   -↑(List.foldl addLsb 0 (a :: x))
a: Bool

x: List Bool

(↑(2 ^ List.length (List.mapAccumr (fun y c => (y || c, xor y c)) x false).snd *           bif xor a (List.mapAccumr (fun y c => (y || c, xor y c)) x false).fst then 1 else 0) +       ↑(List.foldl addLsb 0 (List.mapAccumr (fun y c => (y || c, xor y c)) x false).snd) -     2 ^ List.length (a :: x) * bif a || (List.mapAccumr (fun y c => (y || c, xor y c)) x false).fst then 1 else 0) =   -(↑(2 ^ List.length x * bif a then 1 else 0) + ↑(List.foldl addLsb 0 x))
a: Bool

x: List Bool

(↑(List.foldl addLsb 0
        (xor a (List.mapAccumr (fun y c => (y || c, xor y c)) x false).fst ::           (List.mapAccumr (fun y c => (y || c, xor y c)) x false).snd)) -     2 ^ List.length (a :: x) * bif a || (List.mapAccumr (fun y c => (y || c, xor y c)) x false).fst then 1 else 0) =   -↑(List.foldl addLsb 0 (a :: x))
a: Bool

x: List Bool

(↑(2 ^ List.length (List.mapAccumr (fun y c => (y || c, xor y c)) x false).snd *           bif xor a (List.mapAccumr (fun y c => (y || c, xor y c)) x false).fst then 1 else 0) +       ↑(List.foldl addLsb 0 (List.mapAccumr (fun y c => (y || c, xor y c)) x false).snd) -     2 ^ List.length (a :: x) * bif a || (List.mapAccumr (fun y c => (y || c, xor y c)) x false).fst then 1 else 0) =   -↑(2 ^ List.length x * bif a then 1 else 0) + -↑(List.foldl addLsb 0 x)
a: Bool

x: List Bool

(↑(List.foldl addLsb 0
        (xor a (List.mapAccumr (fun y c => (y || c, xor y c)) x false).fst ::           (List.mapAccumr (fun y c => (y || c, xor y c)) x false).snd)) -     2 ^ List.length (a :: x) * bif a || (List.mapAccumr (fun y c => (y || c, xor y c)) x false).fst then 1 else 0) =   -↑(List.foldl addLsb 0 (a :: x))
a: Bool

x: List Bool

(↑(2 ^ List.length (List.mapAccumr (fun y c => (y || c, xor y c)) x false).snd *           bif xor a (List.mapAccumr (fun y c => (y || c, xor y c)) x false).fst then 1 else 0) +       ↑(List.foldl addLsb 0 (List.mapAccumr (fun y c => (y || c, xor y c)) x false).snd) -     2 ^ List.length (a :: x) * bif a || (List.mapAccumr (fun y c => (y || c, xor y c)) x false).fst then 1 else 0) =   -↑(2 ^ List.length x * bif a then 1 else 0) +     (↑(List.foldl addLsb 0 (List.mapAccumr (fun y c => (y || c, xor y c)) x false).snd) -       2 ^ List.length x * bif (List.mapAccumr (fun y c => (y || c, xor y c)) x false).fst then 1 else 0)
a: Bool

x: List Bool

(↑(2 ^ List.length (List.mapAccumr (fun y c => (y || c, xor y c)) x false).snd *           bif xor a (List.mapAccumr (fun y c => (y || c, xor y c)) x false).fst then 1 else 0) +       ↑(List.foldl addLsb 0 (List.mapAccumr (fun y c => (y || c, xor y c)) x false).snd) -     2 ^ List.length (a :: x) * bif a || (List.mapAccumr (fun y c => (y || c, xor y c)) x false).fst then 1 else 0) =   -↑(2 ^ List.length x * bif a then 1 else 0) +     (↑(List.foldl addLsb 0 (List.mapAccumr (fun y c => (y || c, xor y c)) x false).snd) -       2 ^ List.length x * bif (List.mapAccumr (fun y c => (y || c, xor y c)) x false).fst then 1 else 0)
a: Bool

x: List Bool

(↑(List.foldl addLsb 0 (List.mapAccumr (fun y c => (y || c, xor y c)) (a :: x) false).snd) -     2 ^ List.length (a :: x) * bif (List.mapAccumr (fun y c => (y || c, xor y c)) (a :: x) false).fst then 1 else 0) =   -↑(List.foldl addLsb 0 (a :: x))
a: Bool

x: List Bool

(2 ^ List.length x * ↑(bif xor a (List.mapAccumr (fun y c => (y || c, xor y c)) x false).fst then 1 else 0) +       ↑(List.foldl addLsb 0 (List.mapAccumr (fun y c => (y || c, xor y c)) x false).snd) -     2 ^ Nat.succ (List.length x) * bif a || (List.mapAccumr (fun y c => (y || c, xor y c)) x false).fst then 1 else 0) =   -(2 ^ List.length x * ↑(bif a then 1 else 0)) +     (↑(List.foldl addLsb 0 (List.mapAccumr (fun y c => (y || c, xor y c)) x false).snd) -       2 ^ List.length x * bif (List.mapAccumr (fun y c => (y || c, xor y c)) x false).fst then 1 else 0)
a: Bool

x: List Bool

(↑(List.foldl addLsb 0 (List.mapAccumr (fun y c => (y || c, xor y c)) (a :: x) false).snd) -     2 ^ List.length (a :: x) * bif (List.mapAccumr (fun y c => (y || c, xor y c)) (a :: x) false).fst then 1 else 0) =   -↑(List.foldl addLsb 0 (a :: x))
x: List Bool

false
(2 ^ List.length x * ↑(bif xor false (List.mapAccumr (fun y c => (y || c, xor y c)) x false).fst then 1 else 0) +       ↑(List.foldl addLsb 0 (List.mapAccumr (fun y c => (y || c, xor y c)) x false).snd) -     2 ^ Nat.succ (List.length x) *       bif false || (List.mapAccumr (fun y c => (y || c, xor y c)) x false).fst then 1 else 0) =   -(2 ^ List.length x * ↑(bif false then 1 else 0)) +     (↑(List.foldl addLsb 0 (List.mapAccumr (fun y c => (y || c, xor y c)) x false).snd) -       2 ^ List.length x * bif (List.mapAccumr (fun y c => (y || c, xor y c)) x false).fst then 1 else 0)
x: List Bool

true
(2 ^ List.length x * ↑(bif xor true (List.mapAccumr (fun y c => (y || c, xor y c)) x false).fst then 1 else 0) +       ↑(List.foldl addLsb 0 (List.mapAccumr (fun y c => (y || c, xor y c)) x false).snd) -     2 ^ Nat.succ (List.length x) *       bif true || (List.mapAccumr (fun y c => (y || c, xor y c)) x false).fst then 1 else 0) =   -(2 ^ List.length x * ↑(bif true then 1 else 0)) +     (↑(List.foldl addLsb 0 (List.mapAccumr (fun y c => (y || c, xor y c)) x false).snd) -       2 ^ List.length x * bif (List.mapAccumr (fun y c => (y || c, xor y c)) x false).fst then 1 else 0)
a: Bool

x: List Bool

(2 ^ List.length x * ↑(bif xor a (List.mapAccumr (fun y c => (y || c, xor y c)) x false).fst then 1 else 0) +       ↑(List.foldl addLsb 0 (List.mapAccumr (fun y c => (y || c, xor y c)) x false).snd) -     2 ^ Nat.succ (List.length x) * bif a || (List.mapAccumr (fun y c => (y || c, xor y c)) x false).fst then 1 else 0) =   -(2 ^ List.length x * ↑(bif a then 1 else 0)) +     (↑(List.foldl addLsb 0 (List.mapAccumr (fun y c => (y || c, xor y c)) x false).snd) -       2 ^ List.length x * bif (List.mapAccumr (fun y c => (y || c, xor y c)) x false).fst then 1 else 0)
x: List Bool

false
(2 ^ List.length x * ↑(bif xor false (List.mapAccumr (fun y c => (y || c, xor y c)) x false).fst then 1 else 0) +       ↑(List.foldl addLsb 0 (List.mapAccumr (fun y c => (y || c, xor y c)) x false).snd) -     2 ^ Nat.succ (List.length x) *       bif false || (List.mapAccumr (fun y c => (y || c, xor y c)) x false).fst then 1 else 0) =   -(2 ^ List.length x * ↑(bif false then 1 else 0)) +     (↑(List.foldl addLsb 0 (List.mapAccumr (fun y c => (y || c, xor y c)) x false).snd) -       2 ^ List.length x * bif (List.mapAccumr (fun y c => (y || c, xor y c)) x false).fst then 1 else 0)
x: List Bool

true
(2 ^ List.length x * ↑(bif xor true (List.mapAccumr (fun y c => (y || c, xor y c)) x false).fst then 1 else 0) +       ↑(List.foldl addLsb 0 (List.mapAccumr (fun y c => (y || c, xor y c)) x false).snd) -     2 ^ Nat.succ (List.length x) *       bif true || (List.mapAccumr (fun y c => (y || c, xor y c)) x false).fst then 1 else 0) =   -(2 ^ List.length x * ↑(bif true then 1 else 0)) +     (↑(List.foldl addLsb 0 (List.mapAccumr (fun y c => (y || c, xor y c)) x false).snd) -       2 ^ List.length x * bif (List.mapAccumr (fun y c => (y || c, xor y c)) x false).fst then 1 else 0)
a: Bool

x: List Bool

(2 ^ List.length x * ↑(bif xor a (List.mapAccumr (fun y c => (y || c, xor y c)) x false).fst then 1 else 0) +       ↑(List.foldl addLsb 0 (List.mapAccumr (fun y c => (y || c, xor y c)) x false).snd) -     2 ^ Nat.succ (List.length x) * bif a || (List.mapAccumr (fun y c => (y || c, xor y c)) x false).fst then 1 else 0) =   -(2 ^ List.length x * ↑(bif a then 1 else 0)) +     (↑(List.foldl addLsb 0 (List.mapAccumr (fun y c => (y || c, xor y c)) x false).snd) -       2 ^ List.length x * bif (List.mapAccumr (fun y c => (y || c, xor y c)) x false).fst then 1 else 0)
x: List Bool

true.false
(2 ^ List.length x * ↑(bif xor true false then 1 else 0) +       ↑(List.foldl addLsb 0 (List.mapAccumr (fun y c => (y || c, xor y c)) x false).snd) -     2 ^ Nat.succ (List.length x) * bif true || false then 1 else 0) =   -(2 ^ List.length x * ↑(bif true then 1 else 0)) +     (↑(List.foldl addLsb 0 (List.mapAccumr (fun y c => (y || c, xor y c)) x false).snd) -       2 ^ List.length x * bif false then 1 else 0)
x: List Bool

true.true
(2 ^ List.length x * ↑(bif xor true true then 1 else 0) +       ↑(List.foldl addLsb 0 (List.mapAccumr (fun y c => (y || c, xor y c)) x false).snd) -     2 ^ Nat.succ (List.length x) * bif true || true then 1 else 0) =   -(2 ^ List.length x * ↑(bif true then 1 else 0)) +     (↑(List.foldl addLsb 0 (List.mapAccumr (fun y c => (y || c, xor y c)) x false).snd) -       2 ^ List.length x * bif true then 1 else 0)
a: Bool

x: List Bool

(2 ^ List.length x * ↑(bif xor a (List.mapAccumr (fun y c => (y || c, xor y c)) x false).fst then 1 else 0) +       ↑(List.foldl addLsb 0 (List.mapAccumr (fun y c => (y || c, xor y c)) x false).snd) -     2 ^ Nat.succ (List.length x) * bif a || (List.mapAccumr (fun y c => (y || c, xor y c)) x false).fst then 1 else 0) =   -(2 ^ List.length x * ↑(bif a then 1 else 0)) +     (↑(List.foldl addLsb 0 (List.mapAccumr (fun y c => (y || c, xor y c)) x false).snd) -       2 ^ List.length x * bif (List.mapAccumr (fun y c => (y || c, xor y c)) x false).fst then 1 else 0)
x: List Bool

false.false
(2 ^ List.length x * ↑(bif xor false false then 1 else 0) +       ↑(List.foldl addLsb 0 (List.mapAccumr (fun y c => (y || c, xor y c)) x false).snd) -     2 ^ Nat.succ (List.length x) * bif false || false then 1 else 0) =   -(2 ^ List.length x * ↑(bif false then 1 else 0)) +     (↑(List.foldl addLsb 0 (List.mapAccumr (fun y c => (y || c, xor y c)) x false).snd) -       2 ^ List.length x * bif false then 1 else 0)
x: List Bool

false.true
(2 ^ List.length x * ↑(bif xor false true then 1 else 0) +       ↑(List.foldl addLsb 0 (List.mapAccumr (fun y c => (y || c, xor y c)) x false).snd) -     2 ^ Nat.succ (List.length x) * bif false || true then 1 else 0) =   -(2 ^ List.length x * ↑(bif false then 1 else 0)) +     (↑(List.foldl addLsb 0 (List.mapAccumr (fun y c => (y || c, xor y c)) x false).snd) -       2 ^ List.length x * bif true then 1 else 0)
x: List Bool

true.false
(2 ^ List.length x * ↑(bif xor true false then 1 else 0) +       ↑(List.foldl addLsb 0 (List.mapAccumr (fun y c => (y || c, xor y c)) x false).snd) -     2 ^ Nat.succ (List.length x) * bif true || false then 1 else 0) =   -(2 ^ List.length x * ↑(bif true then 1 else 0)) +     (↑(List.foldl addLsb 0 (List.mapAccumr (fun y c => (y || c, xor y c)) x false).snd) -       2 ^ List.length x * bif false then 1 else 0)
x: List Bool

true.true
(2 ^ List.length x * ↑(bif xor true true then 1 else 0) +       ↑(List.foldl addLsb 0 (List.mapAccumr (fun y c => (y || c, xor y c)) x false).snd) -     2 ^ Nat.succ (List.length x) * bif true || true then 1 else 0) =   -(2 ^ List.length x * ↑(bif true then 1 else 0)) +     (↑(List.foldl addLsb 0 (List.mapAccumr (fun y c => (y || c, xor y c)) x false).snd) -       2 ^ List.length x * bif true then 1 else 0)
a: Bool

x: List Bool

(2 ^ List.length x * ↑(bif xor a (List.mapAccumr (fun y c => (y || c, xor y c)) x false).fst then 1 else 0) +       ↑(List.foldl addLsb 0 (List.mapAccumr (fun y c => (y || c, xor y c)) x false).snd) -     2 ^ Nat.succ (List.length x) * bif a || (List.mapAccumr (fun y c => (y || c, xor y c)) x false).fst then 1 else 0) =   -(2 ^ List.length x * ↑(bif a then 1 else 0)) +     (↑(List.foldl addLsb 0 (List.mapAccumr (fun y c => (y || c, xor y c)) x false).snd) -       2 ^ List.length x * bif (List.mapAccumr (fun y c => (y || c, xor y c)) x false).fst then 1 else 0)
x: List Bool

true.false
2 ^ List.length x + ↑(List.foldl addLsb 0 (List.mapAccumr (fun y c => (y || c, xor y c)) x false).snd) +     (-2 ^ List.length x + -2 ^ List.length x) =   -2 ^ List.length x + ↑(List.foldl addLsb 0 (List.mapAccumr (fun y c => (y || c, xor y c)) x false).snd)
a: Bool

x: List Bool

(2 ^ List.length x * ↑(bif xor a (List.mapAccumr (fun y c => (y || c, xor y c)) x false).fst then 1 else 0) +       ↑(List.foldl addLsb 0 (List.mapAccumr (fun y c => (y || c, xor y c)) x false).snd) -     2 ^ Nat.succ (List.length x) * bif a || (List.mapAccumr (fun y c => (y || c, xor y c)) x false).fst then 1 else 0) =   -(2 ^ List.length x * ↑(bif a then 1 else 0)) +     (↑(List.foldl addLsb 0 (List.mapAccumr (fun y c => (y || c, xor y c)) x false).snd) -       2 ^ List.length x * bif (List.mapAccumr (fun y c => (y || c, xor y c)) x false).fst then 1 else 0)
x: List Bool

false.true
2 ^ List.length x + ↑(List.foldl addLsb 0 (List.mapAccumr (fun y c => (y || c, xor y c)) x false).snd) +     (-2 ^ List.length x + -2 ^ List.length x) =   ↑(List.foldl addLsb 0 (List.mapAccumr (fun y c => (y || c, xor y c)) x false).snd) + -2 ^ List.length x
x: List Bool

true.false
2 ^ List.length x + ↑(List.foldl addLsb 0 (List.mapAccumr (fun y c => (y || c, xor y c)) x false).snd) +     (-2 ^ List.length x + -2 ^ List.length x) =   -2 ^ List.length x + ↑(List.foldl addLsb 0 (List.mapAccumr (fun y c => (y || c, xor y c)) x false).snd)
x: List Bool

true.true
↑(List.foldl addLsb 0 (List.mapAccumr (fun y c => (y || c, xor y c)) x false).snd) +     (-2 ^ List.length x + -2 ^ List.length x) =   -2 ^ List.length x +     (↑(List.foldl addLsb 0 (List.mapAccumr (fun y c => (y || c, xor y c)) x false).snd) + -2 ^ List.length x)
a: Bool

x: List Bool

(2 ^ List.length x * ↑(bif xor a (List.mapAccumr (fun y c => (y || c, xor y c)) x false).fst then 1 else 0) +       ↑(List.foldl addLsb 0 (List.mapAccumr (fun y c => (y || c, xor y c)) x false).snd) -     2 ^ Nat.succ (List.length x) * bif a || (List.mapAccumr (fun y c => (y || c, xor y c)) x false).fst then 1 else 0) =   -(2 ^ List.length x * ↑(bif a then 1 else 0)) +     (↑(List.foldl addLsb 0 (List.mapAccumr (fun y c => (y || c, xor y c)) x false).snd) -       2 ^ List.length x * bif (List.mapAccumr (fun y c => (y || c, xor y c)) x false).fst then 1 else 0)
Goals accomplished! πŸ™

    
theorem 
toZMod_neg: βˆ€ {n : β„•} (x : Bitvec n), toZMod (-x) = -toZMod x
toZMod_neg {
n: β„•
n : 
β„•: Type
β„•} (
x: Bitvec n
x : 
Bitvec: β„• β†’ Type
Bitvec 
n: β„•
n) : (-
x: Bitvec n
x).
toZMod: {n : β„•} β†’ Bitvec n β†’ ZMod (2 ^ n)
toZMod = -
x: Bitvec n
x.
toZMod: {n : β„•} β†’ Bitvec n β†’ ZMod (2 ^ n)
toZMod := 
Goals accomplished! πŸ™
n: β„•

x: Bitvec n

toZMod (-x) = -toZMod x
n: β„•

x: Bitvec n

toZMod (Bitvec.neg x) = -toZMod x
n: β„•

x: Bitvec n

toZMod (-x) = -toZMod x
n: β„•

x: List Bool

hx: List.length x = n

mk
toZMod (Bitvec.neg { val := x, property := hx }) = -toZMod { val := x, property := hx }
n: β„•

x: Bitvec n

toZMod (-x) = -toZMod x
n: β„•

x: List Bool

hx: List.length x = n

mk
↑(List.foldl addLsb 0 (List.mapAccumr (fun y c => (y || c, xor y c)) x false).snd) = -↑(List.foldl addLsb 0 x)
n: β„•

x: Bitvec n

toZMod (-x) = -toZMod x
n: β„•

x: List Bool

hx: List.length x = n

mk
↑(List.foldl addLsb 0 (List.mapAccumr (fun y c => (y || c, xor y c)) x false).snd) = -↑(List.foldl addLsb 0 x)
Goals accomplished! πŸ™
n: β„•

x: List Bool

hx: List.length x = n

2 ^ n = 0
n: β„•

x: List Bool

hx: List.length x = n

2 ^ n = 0
n: β„•

x: List Bool

hx: List.length x = n

↑2 ^ n = 0
n: β„•

x: List Bool

hx: List.length x = n

2 ^ n = 0
n: β„•

x: List Bool

hx: List.length x = n

↑(2 ^ n) = 0
n: β„•

x: List Bool

hx: List.length x = n

2 ^ n = 0
n: β„•

x: List Bool

hx: List.length x = n

0 = 0
Goals accomplished! πŸ™
n: β„•

x: Bitvec n

toZMod (-x) = -toZMod x
n: β„•

x: List Bool

hx: List.length x = n

h2n: 2 ^ n = 0

this: ↑(↑(List.foldl addLsb 0 (List.mapAccumr (fun y c => (y || c, xor y c)) x false).snd) -       2 ^ List.length x * bif (List.mapAccumr (fun y c => (y || c, xor y c)) x false).fst then 1 else 0) =   ↑(-↑(List.foldl addLsb 0 x))

mk
↑(List.foldl addLsb 0 (List.mapAccumr (fun y c => (y || c, xor y c)) x false).snd) = -↑(List.foldl addLsb 0 x)
n: β„•

x: Bitvec n

toZMod (-x) = -toZMod x
x: List Bool

h2n: 2 ^ List.length x = 0

this: ↑(↑(List.foldl addLsb 0 (List.mapAccumr (fun y c => (y || c, xor y c)) x false).snd) -       2 ^ List.length x * bif (List.mapAccumr (fun y c => (y || c, xor y c)) x false).fst then 1 else 0) =   ↑(-↑(List.foldl addLsb 0 x))

mk
↑(List.foldl addLsb 0 (List.mapAccumr (fun y c => (y || c, xor y c)) x false).snd) = -↑(List.foldl addLsb 0 x)
n: β„•

x: Bitvec n

toZMod (-x) = -toZMod x
Goals accomplished! πŸ™



instance: {n : β„•} β†’ SMul β„€ (Bitvec n)
instance : 
SMul: Type ?u.225481 β†’ Type ?u.225480 β†’ Type (max?u.225481?u.225480)
SMul 
β„€: Type
β„€ (
Bitvec: β„• β†’ Type
Bitvec 
n: ?m.225477
n) := ⟨
zsmulRec: {M : Type ?u.225493} β†’ [inst : Zero M] β†’ [inst : Add M] β†’ [inst : Neg M] β†’ β„€ β†’ M β†’ M
zsmulRec⟩

theorem 
zsmul_def: βˆ€ {n : β„•} (x : Bitvec n) (y : β„€), y β€’ x = zsmulRec y x
zsmul_def {
n: β„•
n : 
β„•: Type
β„•} (
x: Bitvec n
x : 
Bitvec: β„• β†’ Type
Bitvec 
n: β„•
n) (
y: β„€
y : 
β„€: Type
β„€) : 
y: β„€
y β€’ 
x: Bitvec n
x = 
zsmulRec: {M : Type ?u.225880} β†’ [inst : Zero M] β†’ [inst : Add M] β†’ [inst : Neg M] β†’ β„€ β†’ M β†’ M
zsmulRec 
y: β„€
y 
x: Bitvec n
x := 
rfl: βˆ€ {Ξ± : Sort ?u.225923} {a : Ξ±}, a = a
rfl

@[simp]
theorem 
toZMod_zsmul: βˆ€ {n : β„•} (x : Bitvec n) (y : β„€), toZMod (y β€’ x) = y β€’ toZMod x
toZMod_zsmul {
n: β„•
n : 
β„•: Type
β„•} (
x: Bitvec n
x : 
Bitvec: β„• β†’ Type
Bitvec 
n: β„•
n) (
y: β„€
y : 
β„€: Type
β„€) : (
y: β„€
y β€’ 
x: Bitvec n
x).
toZMod: {n : β„•} β†’ Bitvec n β†’ ZMod (2 ^ n)
toZMod = 
y: β„€
y β€’ 
x: Bitvec n
x.
toZMod: {n : β„•} β†’ Bitvec n β†’ ZMod (2 ^ n)
toZMod := 
Goals accomplished! πŸ™
n: β„•

x: Bitvec n

y: β„€

toZMod (y β€’ x) = y β€’ toZMod x
n: β„•

x: Bitvec n

y: β„€

toZMod (y β€’ x) = y β€’ toZMod x
n: β„•

x: Bitvec n

y: β„•

ofNat
toZMod (Int.ofNat y β€’ x) = Int.ofNat y β€’ toZMod x
Goals accomplished! πŸ™
n: β„•

x: Bitvec n

y: β„€

toZMod (y β€’ x) = y β€’ toZMod x
n: β„•

x: Bitvec n

y: β„•

negSucc
toZMod (Int.negSucc y β€’ x) = Int.negSucc y β€’ toZMod x
Goals accomplished! πŸ™



instance: {n : β„•} β†’ AddCommGroup (Bitvec n)
instance : 
AddCommGroup: Type ?u.230846 β†’ Type ?u.230846
AddCommGroup (
Bitvec: β„• β†’ Type
Bitvec 
n: ?m.230843
n) := 
  
Function.Injective.addCommGroup: {M₁ : Type ?u.230850} β†’
  {Mβ‚‚ : Type ?u.230849} β†’
    [inst : Add M₁] β†’
      [inst_1 : Zero M₁] β†’
        [inst_2 : SMul β„• M₁] β†’
          [inst_3 : Neg M₁] β†’
            [inst_4 : Sub M₁] β†’
              [inst_5 : SMul β„€ M₁] β†’
                [inst_6 : AddCommGroup Mβ‚‚] β†’
                  (f : M₁ β†’ Mβ‚‚) β†’
                    Function.Injective f β†’
                      f 0 = 0 β†’
                        (βˆ€ (x y : M₁), f (x + y) = f x + f y) β†’
                          (βˆ€ (x : M₁), f (-x) = -f x) β†’
                            (βˆ€ (x y : M₁), f (x - y) = f x - f y) β†’
                              (βˆ€ (x : M₁) (n : β„•), f (n β€’ x) = n β€’ f x) β†’
                                (βˆ€ (x : M₁) (n : β„€), f (n β€’ x) = n β€’ f x) β†’ AddCommGroup M₁
Function.Injective.addCommGroup 
toZMod: {n : β„•} β†’ Bitvec n β†’ ZMod (2 ^ n)
toZMod 
    (
Function.injective_iff_hasLeftInverse: βˆ€ {Ξ± : Sort ?u.231282} {Ξ² : Sort ?u.231283} [inst : Nonempty Ξ±] {f : Ξ± β†’ Ξ²},
  Function.Injective f ↔ Function.HasLeftInverse f
Function.injective_iff_hasLeftInverse.
2: βˆ€ {a b : Prop}, (a ↔ b) β†’ b β†’ a
2 ⟨
_: ?m.231348
_, 
ofZMod_toZMod: βˆ€ {n : β„•} (v : Bitvec n), ofZMod (toZMod v) = v
ofZMod_toZMod⟩) 
    
toZMod_zero: βˆ€ {n : β„•}, toZMod 0 = 0
toZMod_zero 
toZMod_add: βˆ€ {n : β„•} (x y : Bitvec n), toZMod (x + y) = toZMod x + toZMod y
toZMod_add 
toZMod_neg: βˆ€ {n : β„•} (x : Bitvec n), toZMod (-x) = -toZMod x
toZMod_neg 
toZMod_sub: βˆ€ {n : β„•} (x y : Bitvec n), toZMod (x - y) = toZMod x - toZMod y
toZMod_sub 
toZMod_nsmul: βˆ€ {n : β„•} (x : Bitvec n) (y : β„•), toZMod (y β€’ x) = y β€’ toZMod x
toZMod_nsmul 
toZMod_zsmul: βˆ€ {n : β„•} (x : Bitvec n) (y : β„€), toZMod (y β€’ x) = y β€’ toZMod x
toZMod_zsmul

-- see https://leanprover.zulipchat.com/#narrow/stream/270676-lean4/topic/Pattern.20matching.20subtypes
def 
add?: {n : β„•} β†’ Bitvec n β†’ Bitvec n β†’ Option (Bitvec n)
add? {
n: β„•
n : 
Nat: Type
Nat} (
x: Bitvec n
x 
y: Bitvec n
y : 
Bitvec: β„• β†’ Type
Bitvec 
n: β„•
n) : 
Option: Type ?u.232586 β†’ Type ?u.232586
Option (
Bitvec: β„• β†’ Type
Bitvec 
n: β„•
n) := match 
Bitvec.adc: {n : β„•} β†’ Bitvec n β†’ Bitvec n β†’ Bool β†’ Bitvec (n + 1)
Bitvec.adc 
x: Bitvec n
x 
y: Bitvec n
y 
false: Bool
false with
  | ⟨
false: Bool
false :: 
z: List Bool
z,
hcons: List.length (false :: z) = n + 1
hcons⟩ => 
some: {Ξ± : Type ?u.232636} β†’ Ξ± β†’ Option Ξ±
some ⟨
z: List Bool
z, 
Goals accomplished! πŸ™
n: β„•

x, y: Bitvec n

z: List Bool

hcons: List.length (false :: z) = n + 1

List.length z = n
Goals accomplished! πŸ™
⟩
  | _ => 
none: {Ξ± : Type ?u.232657} β†’ Option Ξ±
none -- overflow


theorem 
Warning: declaration uses 'sorry'
 {
n: β„•
n : 
Nat: Type
Nat} {
x: Bitvec n
x 
y: Bitvec n
y 
z: Bitvec n
z : 
Bitvec: β„• β†’ Type
Bitvec 
n: β„•
n} : 
add?: {n : β„•} β†’ Bitvec n β†’ Bitvec n β†’ Option (Bitvec n)
add? 
x: Bitvec n
x 
y: Bitvec n
y = 
some: {Ξ± : Type ?u.233476} β†’ Ξ± β†’ Option Ξ±
some 
z: Bitvec n
z β†’ 
x: Bitvec n
x + 
y: Bitvec n
y = 
z: Bitvec n
z := 
sorry: ?m.233532
sorry

/-
#eval  (𝟷𝟢𝟷𝟷).toNat * (𝟷𝟢𝟷𝟷).toNat
#eval  Bitvec.mul (𝟷𝟢𝟷𝟷) (𝟷𝟢𝟷𝟷) |>.toNat
-/
protected def 
mul?: {n : β„•} β†’ Bitvec n β†’ Bitvec n β†’ Option (Bitvec n)
mul? {
n: β„•
n : 
Nat: Type
Nat} (
x: Bitvec n
x 
y: Bitvec n
y : 
Bitvec: β„• β†’ Type
Bitvec 
n: β„•
n) : 
Option: Type ?u.233547 β†’ Type ?u.233547
Option (
Bitvec: β„• β†’ Type
Bitvec 
n: β„•
n) := do
  let 
f: (r : ?m.233571) β†’ (b : ?m.233579 r) β†’ ?m.233580 r b
f 
r: ?m.233571
r 
b: ?m.233574
b := do 
    let 
op₁: ?m.233736
op₁ ← 
Bitvec.add?: {n : β„•} β†’ Bitvec n β†’ Bitvec n β†’ Option (Bitvec n)
Bitvec.add? 
r: ?m.233571
r 
r: ?m.233571
r 
    let 
opβ‚‚: ?m.233784
opβ‚‚ ← 
Bitvec.add?: {n : β„•} β†’ Bitvec n β†’ Bitvec n β†’ Option (Bitvec n)
Bitvec.add? 
op₁: ?m.233736
op₁ 
y: Bitvec n
y
    return 
cond: {Ξ± : Type ?u.233804} β†’ Bool β†’ Ξ± β†’ Ξ± β†’ Ξ±
cond 
b: ?m.233574
b 
opβ‚‚: ?m.233784
opβ‚‚ 
op₁: ?m.233736
op₁
  (
x: Bitvec n
x.
toList: {Ξ± : Type ?u.233583} β†’ {n : β„•} β†’ Vector Ξ± n β†’ List Ξ±
toList).
foldlM: {m : Type ?u.233593 β†’ Type ?u.233592} β†’
  [inst : Monad m] β†’ {s : Type ?u.233593} β†’ {Ξ± : Type ?u.233591} β†’ (s β†’ Ξ± β†’ m s) β†’ s β†’ List Ξ± β†’ m s
foldlM 
f: (r : ?m.233571) β†’ (b : ?m.233579 r) β†’ ?m.233580 r b
f 
0: ?m.233650
0

/-
#eval  Bitvec.mul? (𝟷𝟢𝟷𝟷) (𝟷𝟢𝟷𝟷)
#eval  Bitvec.mul? (𝟢𝟢𝟢𝟢𝟢𝟢𝟷𝟢𝟷𝟷) (𝟢𝟢𝟢𝟢𝟢𝟢𝟷𝟢𝟷𝟷) |>.get!|>.toNat
-/
theorem 
Warning: declaration uses 'sorry'
 : βˆ€ {
n: β„•
n : 
Nat: Type
Nat} {
x: Bitvec n
x 
y: Bitvec n
y 
z: Bitvec n
z : 
Bitvec: β„• β†’ Type
Bitvec 
n: β„•
n}, 
Bitvec.mul?: {n : β„•} β†’ Bitvec n β†’ Bitvec n β†’ Option (Bitvec n)
Bitvec.mul? 
x: Bitvec n
x 
y: Bitvec n
y = 
some: {Ξ± : Type ?u.234279} β†’ Ξ± β†’ Option Ξ±
some 
z: Bitvec n
z β†’ 
x: Bitvec n
x * 
y: Bitvec n
y = 
z: Bitvec n
z := 
sorry: ?m.234343
sorry

/--
The value produced is the unsigned integer quotient of the two operands.
Note that unsigned integer division and signed integer division are distinct operations; for signed integer division, use β€˜sdiv’.
Division by zero is undefined behavior.
-/
def 
udiv?: {w : β„•} β†’ Bitvec w β†’ Bitvec w β†’ Option (Bitvec w)
udiv? {
w: β„•
w : 
Nat: Type
Nat} (
x: Bitvec w
x 
y: Bitvec w
y : 
Bitvec: β„• β†’ Type
Bitvec 
w: β„•
w) : 
Option: Type ?u.234362 β†’ Type ?u.234362
Option $ 
Bitvec: β„• β†’ Type
Bitvec 
w: β„•
w :=
  match 
y: Bitvec w
y.
toNat: {n : β„•} β†’ Bitvec n β†’ β„•
toNat with
    | 
0: β„•
0 => 
none: {Ξ± : Type ?u.234389} β†’ Option Ξ±
none
    | _ => 
some: {Ξ± : Type ?u.234399} β†’ Ξ± β†’ Option Ξ±
some $ 
Bitvec.ofNat: (n : β„•) β†’ β„• β†’ Bitvec n
Bitvec.ofNat 
w: β„•
w (
x: Bitvec w
x.
toNat: {n : β„•} β†’ Bitvec n β†’ β„•
toNat / 
y: Bitvec w
y.
toNat: {n : β„•} β†’ Bitvec n β†’ β„•
toNat)

/--
The value produced is the signed integer quotient of the two operands rounded towards zero.
Note that signed integer division and unsigned integer division are distinct operations; for unsigned integer division, use β€˜udiv’.
Division by zero is undefined behavior.
Overflow also leads to undefined behavior; this is a rare case, but can occur, for example, by doing a 32-bit division of -2147483648 by -1.
-/
def 
sdiv?: {w : β„•} β†’ Bitvec w β†’ Bitvec w β†’ Option (Bitvec w)
sdiv? {
w: β„•
w : 
Nat: Type
Nat} (
x: Bitvec w
x 
y: Bitvec w
y : 
Bitvec: β„• β†’ Type
Bitvec 
w: β„•
w) : 
Option: Type ?u.234723 β†’ Type ?u.234723
Option $ 
Bitvec: β„• β†’ Type
Bitvec 
w: β„•
w := 
  if 
y: Bitvec w
y.
toInt: {n : β„•} β†’ Bitvec n β†’ β„€
toInt = 
0: ?m.234734
0 
  then 
none: {Ξ± : Type ?u.234772} β†’ Option Ξ±
none
  else 
some: {Ξ± : Type ?u.234775} β†’ Ξ± β†’ Option Ξ±
some $ 
Bitvec.ofInt': (n : β„•) β†’ β„€ β†’ Bitvec n
Bitvec.ofInt' 
w: β„•
w (
x: Bitvec w
x.
toInt: {n : β„•} β†’ Bitvec n β†’ β„€
toInt / 
y: Bitvec w
y.
toInt: {n : β„•} β†’ Bitvec n β†’ β„€
toInt)

/--
 If the condition is an i1 and it evaluates to 1, the instruction returns the first value argument; otherwise, it returns the second value argument.
-/
def 
select: {w : β„•} β†’ Bitvec 1 β†’ Bitvec w β†’ Bitvec w β†’ Bitvec w
select {
w: β„•
w : 
Nat: Type
Nat} (
c: Bitvec 1
c : 
Bitvec: β„• β†’ Type
Bitvec 
1: ?m.234951
1) (
x: Bitvec w
x 
y: Bitvec w
y : 
Bitvec: β„• β†’ Type
Bitvec 
w: β„•
w) : 
Bitvec: β„• β†’ Type
Bitvec 
w: β„•
w :=
  
cond: {Ξ± : Type ?u.234976} β†’ Bool β†’ Ξ± β†’ Ξ± β†’ Ξ±
cond 
c: Bitvec 1
c.
head: {Ξ± : Type ?u.234978} β†’ {n : β„•} β†’ Vector Ξ± (Nat.succ n) β†’ Ξ±
head 
x: Bitvec w
x 
y: Bitvec w
y

theorem 
bitwise_eq_eq: βˆ€ {w : β„•} {x y : Bitvec w}, (βˆ€ (i : Fin w), x[i] = y[i]) ↔ x = y
bitwise_eq_eq {
w: β„•
w : 
Nat: Type
Nat} {
x: Bitvec w
x 
y: Bitvec w
y : 
Bitvec: β„• β†’ Type
Bitvec 
w: β„•
w} :
    (forall 
i: Fin w
i : 
Fin: β„• β†’ Type
Fin 
w: β„•
w, 
x: Bitvec w
x[
i: Fin w
i] = 
y: Bitvec w
y[
i: Fin w
i]) ↔ 
x: Bitvec w
x = 
y: Bitvec w
y :=
  ⟨
Vector.ext: βˆ€ {n : β„•} {Ξ± : Type ?u.235454} {v w : Vector Ξ± n}, (βˆ€ (m : Fin n), Vector.get v m = Vector.get w m) β†’ v = w
Vector.ext, fun 
h: ?m.235489
h 
_: ?m.235492
_ => 
h: ?m.235489
h β–Έ 
rfl: βˆ€ {Ξ± : Sort ?u.235494} {a : Ξ±}, a = a
rfl⟩ 

theorem 
ext_get?: βˆ€ {w : β„•} {x y : Bitvec w}, (βˆ€ (i : β„•), List.get? (Vector.toList x) i = List.get? (Vector.toList y) i) β†’ x = y
ext_get? {
w: β„•
w : 
Nat: Type
Nat} {
x: Bitvec w
x 
y: Bitvec w
y : 
Bitvec: β„• β†’ Type
Bitvec 
w: β„•
w} (
h: βˆ€ (i : β„•), List.get? (Vector.toList x) i = List.get? (Vector.toList y) i
h : βˆ€ 
i: ?m.235528
i, 
x: Bitvec w
x.
toList: {Ξ± : Type ?u.235532} β†’ {n : β„•} β†’ Vector Ξ± n β†’ List Ξ±
toList.
get?: {Ξ± : Type ?u.235537} β†’ List Ξ± β†’ β„• β†’ Option Ξ±
get? 
i: ?m.235528
i = 
y: Bitvec w
y.
toList: {Ξ± : Type ?u.235543} β†’ {n : β„•} β†’ Vector Ξ± n β†’ List Ξ±
toList.
get?: {Ξ± : Type ?u.235546} β†’ List Ξ± β†’ β„• β†’ Option Ξ±
get? 
i: ?m.235528
i) : 
x: Bitvec w
x = 
y: Bitvec w
y := 
Goals accomplished! πŸ™
w: β„•

x, y: Bitvec w

h: βˆ€ (i : β„•), List.get? (Vector.toList x) i = List.get? (Vector.toList y) i

x = y
x: List Bool

y: Bitvec (List.length x)

h: βˆ€ (i : β„•),
  List.get? (Vector.toList { val := x, property := (_ : List.length x = List.length x) }) i =     List.get? (Vector.toList y) i

mk
{ val := x, property := (_ : List.length x = List.length x) } = y
w: β„•

x, y: Bitvec w

h: βˆ€ (i : β„•), List.get? (Vector.toList x) i = List.get? (Vector.toList y) i

x = y
x, y: List Bool

hy: List.length y = List.length x

h: βˆ€ (i : β„•),
  List.get? (Vector.toList { val := x, property := (_ : List.length x = List.length x) }) i =     List.get? (Vector.toList { val := y, property := hy }) i

mk.mk
{ val := x, property := (_ : List.length x = List.length x) } = { val := y, property := hy }
w: β„•

x, y: Bitvec w

h: βˆ€ (i : β„•), List.get? (Vector.toList x) i = List.get? (Vector.toList y) i

x = y
Goals accomplished! πŸ™


@[simp]
theorem 
toList_cong: βˆ€ {w₁ wβ‚‚ : β„•} (h : w₁ = wβ‚‚) (b : Bitvec w₁), Vector.toList (Bitvec.cong h b) = Vector.toList b
toList_cong {
w₁: β„•
w₁ 
wβ‚‚: β„•
wβ‚‚ : 
Nat: Type
Nat} (
h: w₁ = wβ‚‚
h : 
w₁: β„•
w₁ = 
wβ‚‚: β„•
wβ‚‚) (
b: Bitvec w₁
b : 
Bitvec: β„• β†’ Type
Bitvec 
w₁: β„•
w₁) : (
Bitvec.cong: {a b : β„•} β†’ a = b β†’ Bitvec a β†’ Bitvec b
Bitvec.cong 
h: w₁ = wβ‚‚
h 
b: Bitvec w₁
b).
toList: {Ξ± : Type ?u.235705} β†’ {n : β„•} β†’ Vector Ξ± n β†’ List Ξ±
toList = 
b: Bitvec w₁
b.
toList: {Ξ± : Type ?u.235713} β†’ {n : β„•} β†’ Vector Ξ± n β†’ List Ξ±
toList := 
  
Goals accomplished! πŸ™
w₁, wβ‚‚: β„•

h: w₁ = wβ‚‚

b: Bitvec w₁

Vector.toList (Bitvec.cong h b) = Vector.toList b
w₁: β„•

b: Bitvec w₁

Vector.toList (Bitvec.cong (_ : w₁ = w₁) b) = Vector.toList b
w₁: β„•

b: Bitvec w₁

Vector.toList (Bitvec.cong (_ : w₁ = w₁) b) = Vector.toList b
w₁, wβ‚‚: β„•

h: w₁ = wβ‚‚

b: Bitvec w₁

Vector.toList (Bitvec.cong h b) = Vector.toList b
Goals accomplished! πŸ™


theorem 
get?_shl: βˆ€ {n : β„•} (x : Bitvec n) (i j : β„•),
  List.get? (Vector.toList (shl x i)) j =     if i + j < n then List.get? (Vector.toList x) (i + j) else if j < n then some false else none
get?_shl (
x: Bitvec n
x : 
Bitvec: β„• β†’ Type
Bitvec 
n: ?m.235775
n) (
i: β„•
i 
j: β„•
j : 
β„•: Type
β„•) : 
    (
x: Bitvec n
x.
shl: {n : β„•} β†’ Bitvec n β†’ β„• β†’ Bitvec n
shl 
i: β„•
i).
toList: {Ξ± : Type ?u.235790} β†’ {n : β„•} β†’ Vector Ξ± n β†’ List Ξ±
toList.
get?: {Ξ± : Type ?u.235795} β†’ List Ξ± β†’ β„• β†’ Option Ξ±
get? 
j: β„•
j = 
      if 
i: β„•
i + 
j: β„•
j < 
n: ?m.235775
n 
      then 
x: Bitvec n
x.
toList: {Ξ± : Type ?u.235851} β†’ {n : β„•} β†’ Vector Ξ± n β†’ List Ξ±
toList.
get?: {Ξ± : Type ?u.235854} β†’ List Ξ± β†’ β„• β†’ Option Ξ±
get? (
i: β„•
i + 
j: β„•
j) 
      else if 
j: β„•
j < 
n: ?m.235775
n then 
false: Bool
false
      else 
none: {Ξ± : Type ?u.235984} β†’ Option Ξ±
none := 
Goals accomplished! πŸ™
n: β„•

x: Bitvec n

i, j: β„•

List.get? (Vector.toList (shl x i)) j =   if i + j < n then List.get? (Vector.toList x) (i + j) else if j < n then some false else none
n: β„•

x: Bitvec n

i, j: β„•

List.get?
    (Vector.toList
      (Bitvec.cong (_ : n - i + min n i = n) (Vector.append (Vector.drop i x) (Vector.replicate (min n i) false))))
    j =   if i + j < n then List.get? (Vector.toList x) (i + j) else if j < n then some false else none
n: β„•

x: Bitvec n

i, j: β„•

List.get? (Vector.toList (shl x i)) j =   if i + j < n then List.get? (Vector.toList x) (i + j) else if j < n then some false else none
i, j: β„•

x: List Bool

mk
List.get?
    (Vector.toList
      (Bitvec.cong (_ : List.length x - i + min (List.length x) i = List.length x)
        (Vector.append (Vector.drop i { val := x, property := (_ : List.length x = List.length x) })
          (Vector.replicate (min (List.length x) i) false))))
    j =   if i + j < List.length x then
    List.get? (Vector.toList { val := x, property := (_ : List.length x = List.length x) }) (i + j)
  else if j < List.length x then some false else none
n: β„•

x: Bitvec n

i, j: β„•

List.get? (Vector.toList (shl x i)) j =   if i + j < n then List.get? (Vector.toList x) (i + j) else if j < n then some false else none
i, j: β„•

x: List Bool

mk
List.get? (List.drop i x ++ List.replicate (min (List.length x) i) false) j =   if i + j < List.length x then List.get? x (i + j) else if j < List.length x then some false else none
n: β„•

x: Bitvec n

i, j: β„•

List.get? (Vector.toList (shl x i)) j =   if i + j < n then List.get? (Vector.toList x) (i + j) else if j < n then some false else none
i, j: β„•

x: List Bool

h₁: i + j < List.length x

mk.inl
List.get? (List.drop i x ++ List.replicate (min (List.length x) i) false) j = List.get? x (i + j)
i, j: β„•

x: List Bool

h₁: Β¬i + j < List.length x

hβ‚‚: j < List.length x

mk.inr.inl
List.get? (List.drop i x ++ List.replicate (min (List.length x) i) false) j = some false
i, j: β„•

x: List Bool

h₁: Β¬i + j < List.length x

hβ‚‚: Β¬j < List.length x

mk.inr.inr
List.get? (List.drop i x ++ List.replicate (min (List.length x) i) false) j = none
n: β„•

x: Bitvec n

i, j: β„•

List.get? (Vector.toList (shl x i)) j =   if i + j < n then List.get? (Vector.toList x) (i + j) else if j < n then some false else none
i, j: β„•

x: List Bool

h₁: i + j < List.length x

mk.inl
List.get? (List.drop i x ++ List.replicate (min (List.length x) i) false) j = List.get? x (i + j)
i, j: β„•

x: List Bool

h₁: i + j < List.length x

mk.inl
List.get? (List.drop i x ++ List.replicate (min (List.length x) i) false) j = List.get? x (i + j)
i, j: β„•

x: List Bool

h₁: Β¬i + j < List.length x

hβ‚‚: j < List.length x

mk.inr.inl
List.get? (List.drop i x ++ List.replicate (min (List.length x) i) false) j = some false
i, j: β„•

x: List Bool

h₁: Β¬i + j < List.length x

hβ‚‚: Β¬j < List.length x

mk.inr.inr
List.get? (List.drop i x ++ List.replicate (min (List.length x) i) false) j = none
i, j: β„•

x: List Bool

h₁: i + j < List.length x

mk.inl
List.get? (List.drop i x ++ List.replicate (min (List.length x) i) false) j = List.get? x (i + j)
i, j: β„•

x: List Bool

h₁: i + j < List.length x

mk.inl
List.get? (List.drop i x) j = List.get? x (i + j)
i, j: β„•

x: List Bool

h₁: i + j < List.length x

mk.inl
j < List.length (List.drop i x)
i, j: β„•

x: List Bool

h₁: i + j < List.length x

mk.inl
List.get? (List.drop i x ++ List.replicate (min (List.length x) i) false) j = List.get? x (i + j)
i, j: β„•

x: List Bool

h₁: i + j < List.length x

mk.inl
List.get? x (i + j) = List.get? x (i + j)
i, j: β„•

x: List Bool

h₁: i + j < List.length x

mk.inl
j < List.length (List.drop i x)
i, j: β„•

x: List Bool

h₁: i + j < List.length x

mk.inl
j < List.length (List.drop i x)
i, j: β„•

x: List Bool

h₁: i + j < List.length x

mk.inl
List.get? (List.drop i x ++ List.replicate (min (List.length x) i) false) j = List.get? x (i + j)
i, j: β„•

x: List Bool

h₁: Β¬i + j < List.length x

hβ‚‚: j < List.length x

mk.inr.inl
List.get? (List.drop i x ++ List.replicate (min (List.length x) i) false) j = some false
i, j: β„•

x: List Bool

h₁: Β¬i + j < List.length x

hβ‚‚: Β¬j < List.length x

mk.inr.inr
List.get? (List.drop i x ++ List.replicate (min (List.length x) i) false) j = none
i, j: β„•

x: List Bool

h₁: i + j < List.length x

mk.inl
j < List.length (List.drop i x)
i, j: β„•

x: List Bool

h₁: i + j < List.length x

mk.inl
j < List.length (List.drop i x)
i, j: β„•

x: List Bool

h₁: i + j < List.length x

mk.inl
j < List.length (List.drop i x)
i, j: β„•

x: List Bool

h₁: i + j < List.length x

mk.inl
j < List.length x - i
i, j: β„•

x: List Bool

h₁: i + j < List.length x

mk.inl
j < List.length x - i
i, j: β„•

x: List Bool

h₁: i + j < List.length x

mk.inl
j < List.length (List.drop i x)
Goals accomplished! πŸ™
i, j: β„•

x: List Bool

h₁: Β¬i + j < List.length x

hβ‚‚: j < List.length x

mk.inr.inl
List.get? (List.drop i x ++ List.replicate (min (List.length x) i) false) j = some false
i, j: β„•

x: List Bool

h₁: Β¬i + j < List.length x

hβ‚‚: Β¬j < List.length x

mk.inr.inr
List.get? (List.drop i x ++ List.replicate (min (List.length x) i) false) j = none
n: β„•

x: Bitvec n

i, j: β„•

List.get? (Vector.toList (shl x i)) j =   if i + j < n then List.get? (Vector.toList x) (i + j) else if j < n then some false else none
i, j: β„•

x: List Bool

h₁: Β¬i + j < List.length x

hβ‚‚: j < List.length x

mk.inr.inl
List.get? (List.drop i x ++ List.replicate (min (List.length x) i) false) j = some false
i, j: β„•

x: List Bool

h₁: Β¬i + j < List.length x

hβ‚‚: j < List.length x

mk.inr.inl
List.get? (List.drop i x ++ List.replicate (min (List.length x) i) false) j = some false
i, j: β„•

x: List Bool

h₁: Β¬i + j < List.length x

hβ‚‚: Β¬j < List.length x

mk.inr.inr
List.get? (List.drop i x ++ List.replicate (min (List.length x) i) false) j = none
i, j: β„•

x: List Bool

h₁: Β¬i + j < List.length x

hβ‚‚: j < List.length x

mk.inr.inl
List.get? (List.drop i x ++ List.replicate (min (List.length x) i) false) j = some false
i, j: β„•

x: List Bool

h₁: Β¬i + j < List.length x

hβ‚‚: j < List.length x

mk.inr.inl
List.get? (List.replicate (min (List.length x) i) false) (j - List.length (List.drop i x)) = some false
i, j: β„•

x: List Bool

h₁: Β¬i + j < List.length x

hβ‚‚: j < List.length x

mk.inr.inl
List.length (List.drop i x) ≀ j
i, j: β„•

x: List Bool

h₁: Β¬i + j < List.length x

hβ‚‚: j < List.length x

mk.inr.inl
List.get? (List.drop i x ++ List.replicate (min (List.length x) i) false) j = some false
i, j: β„•

x: List Bool

h₁: Β¬i + j < List.length x

hβ‚‚: j < List.length x

mk.inr.inl
some
    (List.get (List.replicate (min (List.length x) i) false)
      { val := j - List.length (List.drop i x), isLt := ?mk.inr.inl }) =   some false
i, j: β„•

x: List Bool

h₁: Β¬i + j < List.length x

hβ‚‚: j < List.length x

mk.inr.inl
j - List.length (List.drop i x) < List.length (List.replicate (min (List.length x) i) false)
i, j: β„•

x: List Bool

h₁: Β¬i + j < List.length x

hβ‚‚: j < List.length x

mk.inr.inl
List.length (List.drop i x) ≀ j
i, j: β„•

x: List Bool

h₁: Β¬i + j < List.length x

hβ‚‚: j < List.length x

mk.inr.inl
List.get? (List.drop i x ++ List.replicate (min (List.length x) i) false) j = some false
i, j: β„•

x: List Bool

h₁: Β¬i + j < List.length x

hβ‚‚: j < List.length x

mk.inr.inl
some false = some false
i, j: β„•

x: List Bool

h₁: Β¬i + j < List.length x

hβ‚‚: j < List.length x

mk.inr.inl
j - List.length (List.drop i x) < List.length (List.replicate (min (List.length x) i) false)
i, j: β„•

x: List Bool

h₁: Β¬i + j < List.length x

hβ‚‚: j < List.length x

mk.inr.inl
j - List.length (List.drop i x) < List.length (List.replicate (min (List.length x) i) false)
i, j: β„•

x: List Bool

h₁: Β¬i + j < List.length x

hβ‚‚: j < List.length x

mk.inr.inl
List.length (List.drop i x) ≀ j
i, j: β„•

x: List Bool

h₁: Β¬i + j < List.length x

hβ‚‚: j < List.length x

mk.inr.inl
j - List.length (List.drop i x) < List.length (List.replicate (min (List.length x) i) false)
i, j: β„•

x: List Bool

h₁: Β¬i + j < List.length x

hβ‚‚: j < List.length x

mk.inr.inl
j - List.length (List.drop i x) < List.length (List.replicate (min (List.length x) i) false)
i, j: β„•

x: List Bool

h₁: Β¬i + j < List.length x

hβ‚‚: j < List.length x

mk.inr.inl
List.length (List.drop i x) ≀ j
i, j: β„•

x: List Bool

h₁: Β¬i + j < List.length x

hβ‚‚: j < List.length x

mk.inr.inl
List.get? (List.drop i x ++ List.replicate (min (List.length x) i) false) j = some false
i, j: β„•

x: List Bool

h₁: Β¬i + j < List.length x

hβ‚‚: Β¬j < List.length x

mk.inr.inr
List.get? (List.drop i x ++ List.replicate (min (List.length x) i) false) j = none
i, j: β„•

x: List Bool

h₁: Β¬i + j < List.length x

hβ‚‚: j < List.length x

mk.inr.inl
j - List.length (List.drop i x) < List.length (List.replicate (min (List.length x) i) false)
i, j: β„•

x: List Bool

h₁: Β¬i + j < List.length x

hβ‚‚: j < List.length x

mk.inr.inl
j - List.length (List.drop i x) < List.length (List.replicate (min (List.length x) i) false)
i, j: β„•

x: List Bool

h₁: Β¬i + j < List.length x

hβ‚‚: j < List.length x

mk.inr.inl
j - List.length (List.drop i x) < List.length (List.replicate (min (List.length x) i) false)
i, j: β„•

x: List Bool

h₁: Β¬i + j < List.length x

hβ‚‚: j < List.length x

mk.inr.inl
List.length (List.drop i x) ≀ j
i, j: β„•

x: List Bool

h₁: Β¬i + j < List.length x

hβ‚‚: j < List.length x

mk.inr.inl
j - List.length (List.drop i x) < List.length (List.replicate (min (List.length x) i) false)
Goals accomplished! πŸ™
i, j: β„•

x: List Bool

h₁: Β¬i + j < List.length x

hβ‚‚: j < List.length x

List.length (List.drop i x) ≀ j
Goals accomplished! πŸ™
i, j: β„•

x: List Bool

h₁: Β¬i + j < List.length x

hβ‚‚: j < List.length x

mk.inr.inl
j - List.length (List.drop i x) < List.length (List.replicate (min (List.length x) i) false)
Goals accomplished! πŸ™
i, j: β„•

x: List Bool

h₁: Β¬i + j < List.length x

hβ‚‚: j < List.length x

j < List.length (List.drop i x) + List.length (List.replicate (min (List.length x) i) false)
Goals accomplished! πŸ™
Goals accomplished! πŸ™
i, j: β„•

x: List Bool

h₁: Β¬i + j < List.length x

hβ‚‚: j < List.length x

mk.inr.inl
List.get? (List.drop i x ++ List.replicate (min (List.length x) i) false) j = some false
i, j: β„•

x: List Bool

h₁: Β¬i + j < List.length x

hβ‚‚: Β¬j < List.length x

mk.inr.inr
List.get? (List.drop i x ++ List.replicate (min (List.length x) i) false) j = none
i, j: β„•

x: List Bool

h₁: Β¬i + j < List.length x

hβ‚‚: j < List.length x

mk.inr.inl
List.length (List.drop i x) ≀ j
i, j: β„•

x: List Bool

h₁: Β¬i + j < List.length x

hβ‚‚: j < List.length x

mk.inr.inl
List.length (List.drop i x) ≀ j
Goals accomplished! πŸ™
i, j: β„•

x: List Bool

h₁: Β¬i + j < List.length x

hβ‚‚: Β¬j < List.length x

mk.inr.inr
List.get? (List.drop i x ++ List.replicate (min (List.length x) i) false) j = none
n: β„•

x: Bitvec n

i, j: β„•

List.get? (Vector.toList (shl x i)) j =   if i + j < n then List.get? (Vector.toList x) (i + j) else if j < n then some false else none
i, j: β„•

x: List Bool

h₁: Β¬i + j < List.length x

hβ‚‚: Β¬j < List.length x

mk.inr.inr
List.get? (List.drop i x ++ List.replicate (min (List.length x) i) false) j = none
i, j: β„•

x: List Bool

h₁: Β¬i + j < List.length x

hβ‚‚: Β¬j < List.length x

mk.inr.inr
List.get? (List.drop i x ++ List.replicate (min (List.length x) i) false) j = none
i, j: β„•

x: List Bool

h₁: Β¬i + j < List.length x

hβ‚‚: Β¬j < List.length x

mk.inr.inr
List.get? (List.drop i x ++ List.replicate (min (List.length x) i) false) j = none
i, j: β„•

x: List Bool

h₁: Β¬i + j < List.length x

hβ‚‚: Β¬j < List.length x

mk.inr.inr
List.length (List.drop i x ++ List.replicate (min (List.length x) i) false) ≀ j
i, j: β„•

x: List Bool

h₁: Β¬i + j < List.length x

hβ‚‚: Β¬j < List.length x

mk.inr.inr
List.length (List.drop i x ++ List.replicate (min (List.length x) i) false) ≀ j
i, j: β„•

x: List Bool

h₁: Β¬i + j < List.length x

hβ‚‚: Β¬j < List.length x

mk.inr.inr
List.get? (List.drop i x ++ List.replicate (min (List.length x) i) false) j = none
Goals accomplished! πŸ™
Goals accomplished! πŸ™

  
theorem 
get?_ushr: βˆ€ {n : β„•} (x : Bitvec n) (i j : β„•),
  List.get? (Vector.toList (ushr x i)) j =     if j < Vector.length x then if j < i then some false else List.get? (Vector.toList x) (j - i) else none
get?_ushr (
x: Bitvec n
x : 
Bitvec: β„• β†’ Type
Bitvec 
n: ?m.243378
n) (
i: β„•
i 
j: β„•
j : 
β„•: Type
β„•) : 
    (
x: Bitvec n
x.
ushr: {n : β„•} β†’ Bitvec n β†’ β„• β†’ Bitvec n
ushr 
i: β„•
i).
toList: {Ξ± : Type ?u.243393} β†’ {n : β„•} β†’ Vector Ξ± n β†’ List Ξ±
toList.
get?: {Ξ± : Type ?u.243398} β†’ List Ξ± β†’ β„• β†’ Option Ξ±
get? 
j: β„•
j = 
      if 
j: β„•
j < 
x: Bitvec n
x.
length: {Ξ± : Type ?u.243405} β†’ {n : β„•} β†’ Vector Ξ± n β†’ β„•
length
      then if 
j: β„•
j < 
i: β„•
i
        then 
some: {Ξ± : Type ?u.243438} β†’ Ξ± β†’ Option Ξ±
some 
false: Bool
false
        else 
x: Bitvec n
x.
toList: {Ξ± : Type ?u.243441} β†’ {n : β„•} β†’ Vector Ξ± n β†’ List Ξ±
toList.
get?: {Ξ± : Type ?u.243444} β†’ List Ξ± β†’ β„• β†’ Option Ξ±
get? (
j: β„•
j - 
i: β„•
i)
      else 
none: {Ξ± : Type ?u.243491} β†’ Option Ξ±
none := 
Goals accomplished! πŸ™
n: β„•

x: Bitvec n

i, j: β„•

List.get? (Vector.toList (ushr x i)) j =   if j < Vector.length x then if j < i then some false else List.get? (Vector.toList x) (j - i) else none
n: β„•

x: Bitvec n

i, j: β„•

List.get? (Vector.toList (fillShr x i false)) j =   if j < Vector.length x then if j < i then some false else List.get? (Vector.toList x) (j - i) else none
n: β„•

x: Bitvec n

i, j: β„•

List.get? (Vector.toList (ushr x i)) j =   if j < Vector.length x then if j < i then some false else List.get? (Vector.toList x) (j - i) else none
i, j: β„•

x: List Bool

mk
List.get? (Vector.toList (fillShr { val := x, property := (_ : List.length x = List.length x) } i false)) j =   if j < Vector.length { val := x, property := (_ : List.length x = List.length x) } then
    if j < i then some false
    else List.get? (Vector.toList { val := x, property := (_ : List.length x = List.length x) }) (j - i)
  else none
n: β„•

x: Bitvec n

i, j: β„•

List.get? (Vector.toList (ushr x i)) j =   if j < Vector.length x then if j < i then some false else List.get? (Vector.toList x) (j - i) else none
i, j: β„•

x: List Bool

mk
List.get? (List.replicate (min (List.length x) i) false ++ List.take (List.length x - i) x) j =   if j < Vector.length { val := x, property := (_ : List.length x = List.length x) } then
    if j < i then some false else List.get? x (j - i)
  else none
n: β„•

x: Bitvec n

i, j: β„•

List.get? (Vector.toList (ushr x i)) j =   if j < Vector.length x then if j < i then some false else List.get? (Vector.toList x) (j - i) else none
i, j: β„•

x: List Bool

h₁: j < Vector.length { val := x, property := (_ : List.length x = List.length x) }

hβ‚‚: j < i

mk.inl.inl
List.get? (List.replicate (min (List.length x) i) false ++ List.take (List.length x - i) x) j = some false
i, j: β„•

x: List Bool

h₁: j < Vector.length { val := x, property := (_ : List.length x = List.length x) }

hβ‚‚: Β¬j < i

mk.inl.inr
List.get? (List.replicate (min (List.length x) i) false ++ List.take (List.length x - i) x) j = List.get? x (j - i)
i, j: β„•

x: List Bool

h₁: Β¬j < Vector.length { val := x, property := (_ : List.length x = List.length x) }

mk.inr
List.get? (List.replicate (min (List.length x) i) false ++ List.take (List.length x - i) x) j = none
n: β„•

x: Bitvec n

i, j: β„•

List.get? (Vector.toList (ushr x i)) j =   if j < Vector.length x then if j < i then some false else List.get? (Vector.toList x) (j - i) else none
i, j: β„•

x: List Bool

h₁: j < Vector.length { val := x, property := (_ : List.length x = List.length x) }

hβ‚‚: j < i

mk.inl.inl
List.get? (List.replicate (min (List.length x) i) false ++ List.take (List.length x - i) x) j = some false
i, j: β„•

x: List Bool

h₁: j < Vector.length { val := x, property := (_ : List.length x = List.length x) }

hβ‚‚: j < i

mk.inl.inl
List.get? (List.replicate (min (List.length x) i) false ++ List.take (List.length x - i) x) j = some false
i, j: β„•

x: List Bool

h₁: j < Vector.length { val := x, property := (_ : List.length x = List.length x) }

hβ‚‚: Β¬j < i

mk.inl.inr
List.get? (List.replicate (min (List.length x) i) false ++ List.take (List.length x - i) x) j = List.get? x (j - i)
i, j: β„•

x: List Bool

h₁: Β¬j < Vector.length { val := x, property := (_ : List.length x = List.length x) }

mk.inr
List.get? (List.replicate (min (List.length x) i) false ++ List.take (List.length x - i) x) j = none
i, j: β„•

x: List Bool

h₁: j < Vector.length { val := x, property := (_ : List.length x = List.length x) }

hβ‚‚: j < i

mk.inl.inl
List.get? (List.replicate (min (List.length x) i) false ++ List.take (List.length x - i) x) j = some false
i, j: β„•

x: List Bool

h₁: j < Vector.length { val := x, property := (_ : List.length x = List.length x) }

hβ‚‚: j < i

mk.inl.inl
List.get? (List.replicate (min (List.length x) i) false) j = some false
i, j: β„•

x: List Bool

h₁: j < Vector.length { val := x, property := (_ : List.length x = List.length x) }

hβ‚‚: j < i

mk.inl.inl
j < List.length (List.replicate (min (List.length x) i) false)
i, j: β„•

x: List Bool

h₁: j < Vector.length { val := x, property := (_ : List.length x = List.length x) }

hβ‚‚: j < i

mk.inl.inl
List.get? (List.replicate (min (List.length x) i) false ++ List.take (List.length x - i) x) j = some false
i, j: β„•

x: List Bool

h₁: j < Vector.length { val := x, property := (_ : List.length x = List.length x) }

hβ‚‚: j < i

mk.inl.inl
some (List.get (List.replicate (min (List.length x) i) false) { val := j, isLt := ?mk.inl.inl }) = some false
i, j: β„•

x: List Bool

h₁: j < Vector.length { val := x, property := (_ : List.length x = List.length x) }

hβ‚‚: j < i

mk.inl.inl
j < List.length (List.replicate (min (List.length x) i) false)
i, j: β„•

x: List Bool

h₁: j < Vector.length { val := x, property := (_ : List.length x = List.length x) }

hβ‚‚: j < i

mk.inl.inl
j < List.length (List.replicate (min (List.length x) i) false)
i, j: β„•

x: List Bool

h₁: j < Vector.length { val := x, property := (_ : List.length x = List.length x) }

hβ‚‚: j < i

mk.inl.inl
List.get? (List.replicate (min (List.length x) i) false ++ List.take (List.length x - i) x) j = some false
i, j: β„•

x: List Bool

h₁: j < Vector.length { val := x, property := (_ : List.length x = List.length x) }

hβ‚‚: j < i

mk.inl.inl
some false = some false
i, j: β„•

x: List Bool

h₁: j < Vector.length { val := x, property := (_ : List.length x = List.length x) }

hβ‚‚: j < i

mk.inl.inl
j < List.length (List.replicate (min (List.length x) i) false)
i, j: β„•

x: List Bool

h₁: j < Vector.length { val := x, property := (_ : List.length x = List.length x) }

hβ‚‚: j < i

mk.inl.inl
j < List.length (List.replicate (min (List.length x) i) false)
i, j: β„•

x: List Bool

h₁: j < Vector.length { val := x, property := (_ : List.length x = List.length x) }

hβ‚‚: j < i

mk.inl.inl
j < List.length (List.replicate (min (List.length x) i) false)
i, j: β„•

x: List Bool

h₁: j < Vector.length { val := x, property := (_ : List.length x = List.length x) }

hβ‚‚: j < i

mk.inl.inl
j < List.length (List.replicate (min (List.length x) i) false)
i, j: β„•

x: List Bool

h₁: j < Vector.length { val := x, property := (_ : List.length x = List.length x) }

hβ‚‚: j < i

mk.inl.inl
j < List.length (List.replicate (min (List.length x) i) false)
i, j: β„•

x: List Bool

h₁: j < Vector.length { val := x, property := (_ : List.length x = List.length x) }

hβ‚‚: j < i

mk.inl.inl
j < List.length (List.replicate (min (List.length x) i) false)
i, j: β„•

x: List Bool

h₁: j < Vector.length { val := x, property := (_ : List.length x = List.length x) }

hβ‚‚: j < i

mk.inl.inl
List.get? (List.replicate (min (List.length x) i) false ++ List.take (List.length x - i) x) j = some false
i, j: β„•

x: List Bool

h₁: j < Vector.length { val := x, property := (_ : List.length x = List.length x) }

hβ‚‚: Β¬j < i

mk.inl.inr
List.get? (List.replicate (min (List.length x) i) false ++ List.take (List.length x - i) x) j = List.get? x (j - i)
i, j: β„•

x: List Bool

h₁: Β¬j < Vector.length { val := x, property := (_ : List.length x = List.length x) }

mk.inr
List.get? (List.replicate (min (List.length x) i) false ++ List.take (List.length x - i) x) j = none
i, j: β„•

x: List Bool

h₁: j < Vector.length { val := x, property := (_ : List.length x = List.length x) }

hβ‚‚: j < i

mk.inl.inl
j < List.length (List.replicate (min (List.length x) i) false)
i, j: β„•

x: List Bool

h₁: j < Vector.length { val := x, property := (_ : List.length x = List.length x) }

hβ‚‚: j < i

mk.inl.inl
j < List.length (List.replicate (min (List.length x) i) false)
i, j: β„•

x: List Bool

h₁: j < Vector.length { val := x, property := (_ : List.length x = List.length x) }

hβ‚‚: j < i

mk.inl.inl
j < List.length (List.replicate (min (List.length x) i) false)
i, j: β„•

x: List Bool

h₁: j < Vector.length { val := x, property := (_ : List.length x = List.length x) }

hβ‚‚: j < i

mk.inl.inl
j < List.length (List.replicate (min (List.length x) i) false)
Goals accomplished! πŸ™
i, j: β„•

x: List Bool

h₁: j < Vector.length { val := x, property := (_ : List.length x = List.length x) }

hβ‚‚: j < i

mk.inl.inl
List.get? (List.replicate (min (List.length x) i) false ++ List.take (List.length x - i) x) j = some false
i, j: β„•

x: List Bool

h₁: j < Vector.length { val := x, property := (_ : List.length x = List.length x) }

hβ‚‚: Β¬j < i

mk.inl.inr
List.get? (List.replicate (min (List.length x) i) false ++ List.take (List.length x - i) x) j = List.get? x (j - i)
i, j: β„•

x: List Bool

h₁: Β¬j < Vector.length { val := x, property := (_ : List.length x = List.length x) }

mk.inr
List.get? (List.replicate (min (List.length x) i) false ++ List.take (List.length x - i) x) j = none
i, j: β„•

x: List Bool

h₁: j < Vector.length { val := x, property := (_ : List.length x = List.length x) }

hβ‚‚: j < i

mk.inl.inl
j < List.length (List.replicate (min (List.length x) i) false)
i, j: β„•

x: List Bool

h₁: j < Vector.length { val := x, property := (_ : List.length x = List.length x) }

hβ‚‚: j < i

mk.inl.inl
j < List.length (List.replicate (min (List.length x) i) false)
Goals accomplished! πŸ™
i, j: β„•

x: List Bool

h₁: j < Vector.length { val := x, property := (_ : List.length x = List.length x) }

hβ‚‚: Β¬j < i

mk.inl.inr
List.get? (List.replicate (min (List.length x) i) false ++ List.take (List.length x - i) x) j = List.get? x (j - i)
i, j: β„•

x: List Bool

h₁: Β¬j < Vector.length { val := x, property := (_ : List.length x = List.length x) }

mk.inr
List.get? (List.replicate (min (List.length x) i) false ++ List.take (List.length x - i) x) j = none
n: β„•

x: Bitvec n

i, j: β„•

List.get? (Vector.toList (ushr x i)) j =   if j < Vector.length x then if j < i then some false else List.get? (Vector.toList x) (j - i) else none
i, j: β„•

x: List Bool

h₁: j < Vector.length { val := x, property := (_ : List.length x = List.length x) }

hβ‚‚: Β¬j < i

mk.inl.inr
List.get? (List.replicate (min (List.length x) i) false ++ List.take (List.length x - i) x) j = List.get? x (j - i)
i, j: β„•

x: List Bool

h₁: j < Vector.length { val := x, property := (_ : List.length x = List.length x) }

hβ‚‚: Β¬j < i

mk.inl.inr
List.get? (List.replicate (min (List.length x) i) false ++ List.take (List.length x - i) x) j = List.get? x (j - i)
i, j: β„•

x: List Bool

h₁: Β¬j < Vector.length { val := x, property := (_ : List.length x = List.length x) }

mk.inr
List.get? (List.replicate (min (List.length x) i) false ++ List.take (List.length x - i) x) j = none
i, j: β„•

x: List Bool

h₁: j < Vector.length { val := x, property := (_ : List.length x = List.length x) }

hβ‚‚: Β¬j < i

this: i < List.length x

mk.inl.inr
List.get? (List.replicate (min (List.length x) i) false ++ List.take (List.length x - i) x) j = List.get? x (j - i)
i, j: β„•

x: List Bool

h₁: j < Vector.length { val := x, property := (_ : List.length x = List.length x) }

hβ‚‚: Β¬j < i

mk.inl.inr
List.get? (List.replicate (min (List.length x) i) false ++ List.take (List.length x - i) x) j = List.get? x (j - i)
i, j: β„•

x: List Bool

h₁: Β¬j < Vector.length { val := x, property := (_ : List.length x = List.length x) }

mk.inr
List.get? (List.replicate (min (List.length x) i) false ++ List.take (List.length x - i) x) j = none
i, j: β„•

x: List Bool

h₁: j < Vector.length { val := x, property := (_ : List.length x = List.length x) }

hβ‚‚: Β¬j < i

this: i < List.length x

mk.inl.inr
List.get? (List.replicate (min (List.length x) i) false ++ List.take (List.length x - i) x) j = List.get? x (j - i)
i, j: β„•

x: List Bool

h₁: j < Vector.length { val := x, property := (_ : List.length x = List.length x) }

hβ‚‚: Β¬j < i

this: i < List.length x

mk.inl.inr
List.get? (List.replicate i false ++ List.take (List.length x - i) x) j = List.get? x (j - i)
i, j: β„•

x: List Bool

h₁: j < Vector.length { val := x, property := (_ : List.length x = List.length x) }

hβ‚‚: Β¬j < i

this: i < List.length x

mk.inl.inr
List.get? (List.replicate (min (List.length x) i) false ++ List.take (List.length x - i) x) j = List.get? x (j - i)
i, j: β„•

x: List Bool

h₁: j < Vector.length { val := x, property := (_ : List.length x = List.length x) }

hβ‚‚: Β¬j < i

this: i < List.length x

mk.inl.inr
List.get? (List.take (List.length x - i) x) (j - List.length (List.replicate i false)) = List.get? x (j - i)
i, j: β„•

x: List Bool

h₁: j < Vector.length { val := x, property := (_ : List.length x = List.length x) }

hβ‚‚: Β¬j < i

this: i < List.length x

mk.inl.inr
List.length (List.replicate i false) ≀ j
i, j: β„•

x: List Bool

h₁: j < Vector.length { val := x, property := (_ : List.length x = List.length x) }

hβ‚‚: Β¬j < i

this: i < List.length x

mk.inl.inr
List.get? (List.replicate (min (List.length x) i) false ++ List.take (List.length x - i) x) j = List.get? x (j - i)
i, j: β„•

x: List Bool

h₁: j < Vector.length { val := x, property := (_ : List.length x = List.length x) }

hβ‚‚: Β¬j < i

this: i < List.length x

mk.inl.inr
List.get? x (j - List.length (List.replicate i false)) = List.get? x (j - i)
i, j: β„•

x: List Bool

h₁: j < Vector.length { val := x, property := (_ : List.length x = List.length x) }

hβ‚‚: Β¬j < i

this: i < List.length x

mk.inl.inr
j - List.length (List.replicate i false) < List.length x - i
i, j: β„•

x: List Bool

h₁: j < Vector.length { val := x, property := (_ : List.length x = List.length x) }

hβ‚‚: Β¬j < i

this: i < List.length x

mk.inl.inr
List.length (List.replicate i false) ≀ j
i, j: β„•

x: List Bool

h₁: j < Vector.length { val := x, property := (_ : List.length x = List.length x) }

hβ‚‚: Β¬j < i

this: i < List.length x

mk.inl.inr
List.get? x (j - List.length (List.replicate i false)) = List.get? x (j - i)
i, j: β„•

x: List Bool

h₁: j < Vector.length { val := x, property := (_ : List.length x = List.length x) }

hβ‚‚: Β¬j < i

this: i < List.length x

mk.inl.inr
j - List.length (List.replicate i false) < List.length x - i
i, j: β„•

x: List Bool

h₁: j < Vector.length { val := x, property := (_ : List.length x = List.length x) }

hβ‚‚: Β¬j < i

this: i < List.length x

mk.inl.inr
List.length (List.replicate i false) ≀ j
i, j: β„•

x: List Bool

h₁: j < Vector.length { val := x, property := (_ : List.length x = List.length x) }

hβ‚‚: Β¬j < i

mk.inl.inr
List.get? (List.replicate (min (List.length x) i) false ++ List.take (List.length x - i) x) j = List.get? x (j - i)
i, j: β„•

x: List Bool

h₁: Β¬j < Vector.length { val := x, property := (_ : List.length x = List.length x) }

mk.inr
List.get? (List.replicate (min (List.length x) i) false ++ List.take (List.length x - i) x) j = none
i, j: β„•

x: List Bool

h₁: j < Vector.length { val := x, property := (_ : List.length x = List.length x) }

hβ‚‚: Β¬j < i

this: i < List.length x

mk.inl.inr
j - List.length (List.replicate i false) < List.length x - i
i, j: β„•

x: List Bool

h₁: j < Vector.length { val := x, property := (_ : List.length x = List.length x) }

hβ‚‚: Β¬j < i

this: i < List.length x

mk.inl.inr
List.length (List.replicate i false) ≀ j
i, j: β„•

x: List Bool

h₁: j < Vector.length { val := x, property := (_ : List.length x = List.length x) }

hβ‚‚: Β¬j < i

mk.inl.inr
List.get? (List.replicate (min (List.length x) i) false ++ List.take (List.length x - i) x) j = List.get? x (j - i)
i, j: β„•

x: List Bool

h₁: Β¬j < Vector.length { val := x, property := (_ : List.length x = List.length x) }

mk.inr
List.get? (List.replicate (min (List.length x) i) false ++ List.take (List.length x - i) x) j = none
i, j: β„•

x: List Bool

h₁: j < Vector.length { val := x, property := (_ : List.length x = List.length x) }

hβ‚‚: Β¬j < i

this: i < List.length x

mk.inl.inr
j - List.length (List.replicate i false) < List.length x - i
i, j: β„•

x: List Bool

h₁: j < Vector.length { val := x, property := (_ : List.length x = List.length x) }

hβ‚‚: Β¬j < i

this: i < List.length x

mk.inl.inr
j - List.length (List.replicate i false) < List.length x - i
i, j: β„•

x: List Bool

h₁: j < Vector.length { val := x, property := (_ : List.length x = List.length x) }

hβ‚‚: Β¬j < i

this: i < List.length x

mk.inl.inr
List.length (List.replicate i false) ≀ j
i, j: β„•

x: List Bool

h₁: j < Vector.length { val := x, property := (_ : List.length x = List.length x) }

hβ‚‚: Β¬j < i

this: i < List.length x

mk.inl.inr
j - List.length (List.replicate i false) < List.length x - i
Goals accomplished! πŸ™
i, j: β„•

x: List Bool

h₁: j < Vector.length { val := x, property := (_ : List.length x = List.length x) }

hβ‚‚: Β¬j < i

this: i < List.length x

List.length (List.replicate i false) ≀ j
Goals accomplished! πŸ™
i, j: β„•

x: List Bool

h₁: j < Vector.length { val := x, property := (_ : List.length x = List.length x) }

hβ‚‚: Β¬j < i

this: i < List.length x

mk.inl.inr
j - List.length (List.replicate i false) < List.length x - i
Goals accomplished! πŸ™
i, j: β„•

x: List Bool

h₁: j < Vector.length { val := x, property := (_ : List.length x = List.length x) }

hβ‚‚: Β¬j < i

this: i < List.length x

j < List.length (List.replicate i false) + (List.length x - i)
Goals accomplished! πŸ™
Goals accomplished! πŸ™
i, j: β„•

x: List Bool

h₁: j < Vector.length { val := x, property := (_ : List.length x = List.length x) }

hβ‚‚: Β¬j < i

mk.inl.inr
List.get? (List.replicate (min (List.length x) i) false ++ List.take (List.length x - i) x) j = List.get? x (j - i)
i, j: β„•

x: List Bool

h₁: Β¬j < Vector.length { val := x, property := (_ : List.length x = List.length x) }

mk.inr
List.get? (List.replicate (min (List.length x) i) false ++ List.take (List.length x - i) x) j = none
i, j: β„•

x: List Bool

h₁: j < Vector.length { val := x, property := (_ : List.length x = List.length x) }

hβ‚‚: Β¬j < i

this: i < List.length x

mk.inl.inr
List.length (List.replicate i false) ≀ j
i, j: β„•

x: List Bool

h₁: j < Vector.length { val := x, property := (_ : List.length x = List.length x) }

hβ‚‚: Β¬j < i

this: i < List.length x

mk.inl.inr
List.length (List.replicate i false) ≀ j
Goals accomplished! πŸ™
i, j: β„•

x: List Bool

h₁: Β¬j < Vector.length { val := x, property := (_ : List.length x = List.length x) }

mk.inr
List.get? (List.replicate (min (List.length x) i) false ++ List.take (List.length x - i) x) j = none
n: β„•

x: Bitvec n

i, j: β„•

List.get? (Vector.toList (ushr x i)) j =   if j < Vector.length x then if j < i then some false else List.get? (Vector.toList x) (j - i) else none
i, j: β„•

x: List Bool

h₁: Β¬j < Vector.length { val := x, property := (_ : List.length x = List.length x) }

mk.inr
List.get? (List.replicate (min (List.length x) i) false ++ List.take (List.length x - i) x) j = none
i, j: β„•

x: List Bool

h₁: Β¬j < Vector.length { val := x, property := (_ : List.length x = List.length x) }

mk.inr
List.get? (List.replicate (min (List.length x) i) false ++ List.take (List.length x - i) x) j = none
i, j: β„•

x: List Bool

h₁: Β¬j < Vector.length { val := x, property := (_ : List.length x = List.length x) }

mk.inr
List.get? (List.replicate (min (List.length x) i) false ++ List.take (List.length x - i) x) j = none
i, j: β„•

x: List Bool

h₁: Β¬j < Vector.length { val := x, property := (_ : List.length x = List.length x) }

mk.inr
List.length (List.replicate (min (List.length x) i) false ++ List.take (List.length x - i) x) ≀ j
i, j: β„•

x: List Bool

h₁: Β¬j < Vector.length { val := x, property := (_ : List.length x = List.length x) }

mk.inr
List.length (List.replicate (min (List.length x) i) false ++ List.take (List.length x - i) x) ≀ j
i, j: β„•

x: List Bool

h₁: Β¬j < Vector.length { val := x, property := (_ : List.length x = List.length x) }

mk.inr
List.get? (List.replicate (min (List.length x) i) false ++ List.take (List.length x - i) x) j = none
i, j: β„•

x: List Bool

h₁: Β¬j < Vector.length { val := x, property := (_ : List.length x = List.length x) }

mk.inr
List.length (List.replicate (min (List.length x) i) false ++ List.take (List.length x - i) x) ≀ j
i, j: β„•

x: List Bool

h₁: Β¬j < Vector.length { val := x, property := (_ : List.length x = List.length x) }

mk.inr
List.length (List.replicate (min (List.length x) i) false ++ List.take (List.length x - i) x) ≀ j
i, j: β„•

x: List Bool

h₁: Β¬j < Vector.length { val := x, property := (_ : List.length x = List.length x) }

mk.inr
List.length (List.replicate (min (List.length x) i) false ++ List.take (List.length x - i) x) ≀ j
i, j: β„•

x: List Bool

h₁: Β¬j < Vector.length { val := x, property := (_ : List.length x = List.length x) }

mk.inr
List.length (List.replicate (if List.length x ≀ i then List.length x else i) false ++ List.take (List.length x - i) x) ≀   j
i, j: β„•

x: List Bool

h₁: Β¬j < Vector.length { val := x, property := (_ : List.length x = List.length x) }

mk.inr
List.length (List.replicate (if List.length x ≀ i then List.length x else i) false ++ List.take (List.length x - i) x) ≀   j
i, j: β„•

x: List Bool

h₁: Β¬j < Vector.length { val := x, property := (_ : List.length x = List.length x) }

mk.inr
List.length (List.replicate (min (List.length x) i) false ++ List.take (List.length x - i) x) ≀ j
i, j: β„•

x: List Bool

h₁: Β¬j < Vector.length { val := x, property := (_ : List.length x = List.length x) }

h: List.length x ≀ i

mk.inr.inl
List.length (List.replicate (List.length x) false ++ List.take (List.length x - i) x) ≀ j
i, j: β„•

x: List Bool

h₁: Β¬j < Vector.length { val := x, property := (_ : List.length x = List.length x) }

h: Β¬List.length x ≀ i

mk.inr.inr
List.length (List.replicate i false ++ List.take (List.length x - i) x) ≀ j
i, j: β„•

x: List Bool

h₁: Β¬j < Vector.length { val := x, property := (_ : List.length x = List.length x) }

mk.inr
List.length (List.replicate (min (List.length x) i) false ++ List.take (List.length x - i) x) ≀ j
i, j: β„•

x: List Bool

h₁: Β¬j < Vector.length { val := x, property := (_ : List.length x = List.length x) }

h: List.length x ≀ i

mk.inr.inl
List.length (List.replicate (List.length x) false ++ List.take (List.length x - i) x) ≀ j
i, j: β„•

x: List Bool

h₁: Β¬j < Vector.length { val := x, property := (_ : List.length x = List.length x) }

h: List.length x ≀ i

mk.inr.inl
List.length (List.replicate (List.length x) false ++ List.take (List.length x - i) x) ≀ j
i, j: β„•

x: List Bool

h₁: Β¬j < Vector.length { val := x, property := (_ : List.length x = List.length x) }

h: Β¬List.length x ≀ i

mk.inr.inr
List.length (List.replicate i false ++ List.take (List.length x - i) x) ≀ j
Goals accomplished! πŸ™
i, j: β„•

x: List Bool

h₁: Β¬j < Vector.length { val := x, property := (_ : List.length x = List.length x) }

h: Β¬List.length x ≀ i

mk.inr.inr
List.length (List.replicate i false ++ List.take (List.length x - i) x) ≀ j
i, j: β„•

x: List Bool

h₁: Β¬j < Vector.length { val := x, property := (_ : List.length x = List.length x) }

mk.inr
List.length (List.replicate (min (List.length x) i) false ++ List.take (List.length x - i) x) ≀ j
i, j: β„•

x: List Bool

h₁: Β¬j < Vector.length { val := x, property := (_ : List.length x = List.length x) }

h: Β¬List.length x ≀ i

mk.inr.inr
List.length (List.replicate i false ++ List.take (List.length x - i) x) ≀ j
i, j: β„•

x: List Bool

h₁: Β¬j < Vector.length { val := x, property := (_ : List.length x = List.length x) }

h: Β¬List.length x ≀ i

mk.inr.inr
List.length (List.replicate i false ++ List.take (List.length x - i) x) ≀ j
Goals accomplished! πŸ™
Goals accomplished! πŸ™
Goals accomplished! πŸ™


theorem 
get?_and: βˆ€ {n : β„•} (x y : Bitvec n) (i : β„•),
  List.get? (Vector.toList (Bitvec.and x y)) i = do
    let __do_lift ← List.get? (Vector.toList x) i
    let __do_lift_1 ← List.get? (Vector.toList y) i
    pure (__do_lift && __do_lift_1)
get?_and (
x: Bitvec n
x 
y: Bitvec n
y : 
Bitvec: β„• β†’ Type
Bitvec 
n: ?m.261948
n) (
i: β„•
i : 
β„•: Type
β„•) : 
    (
x: Bitvec n
x.
and: {n : β„•} β†’ Bitvec n β†’ Bitvec n β†’ Bitvec n
and 
y: Bitvec n
y).
toList: {Ξ± : Type ?u.261963} β†’ {n : β„•} β†’ Vector Ξ± n β†’ List Ξ±
toList.
get?: {Ξ± : Type ?u.261968} β†’ List Ξ± β†’ β„• β†’ Option Ξ±
get? 
i: β„•
i = do return 
(← x.toList.get? i): ?m.262050
(← 
x: Bitvec n
x
(← x.toList.get? i): ?m.262050
.
toList: {Ξ± : Type ?u.262040} β†’ {n : β„•} β†’ Vector Ξ± n β†’ List Ξ±
toList
(← x.toList.get? i): ?m.262050
.
get?: {Ξ± : Type ?u.262043} β†’ List Ξ± β†’ β„• β†’ Option Ξ±
get?
(← x.toList.get? i): ?m.262050
 
i: β„•
i
(← x.toList.get? i): ?m.262050
) && 
(← y.toList.get? i): ?m.262105
(← 
y: Bitvec n
y
(← y.toList.get? i): ?m.262105
.
toList: {Ξ± : Type ?u.262096} β†’ {n : β„•} β†’ Vector Ξ± n β†’ List Ξ±
toList
(← y.toList.get? i): ?m.262105
.
get?: {Ξ± : Type ?u.262099} β†’ List Ξ± β†’ β„• β†’ Option Ξ±
get?
(← y.toList.get? i): ?m.262105
 
i: β„•
i
(← y.toList.get? i): ?m.262105
) := 
Goals accomplished! πŸ™
n: β„•

x, y: Bitvec n

i: β„•

List.get? (Vector.toList (Bitvec.and x y)) i = do
  let __do_lift ← List.get? (Vector.toList x) i
  let __do_lift_1 ← List.get? (Vector.toList y) i
  pure (__do_lift && __do_lift_1)
i: β„•

x: List Bool

y: Bitvec (List.length x)

mk
List.get? (Vector.toList (Bitvec.and { val := x, property := (_ : List.length x = List.length x) } y)) i = do
  let __do_lift ← List.get? (Vector.toList { val := x, property := (_ : List.length x = List.length x) }) i
  let __do_lift_1 ← List.get? (Vector.toList y) i
  pure (__do_lift && __do_lift_1)
n: β„•

x, y: Bitvec n

i: β„•

List.get? (Vector.toList (Bitvec.and x y)) i = do
  let __do_lift ← List.get? (Vector.toList x) i
  let __do_lift_1 ← List.get? (Vector.toList y) i
  pure (__do_lift && __do_lift_1)
i: β„•

x, y: List Bool

hy: List.length y = List.length x

mk.mk
List.get?
    (Vector.toList
      (Bitvec.and { val := x, property := (_ : List.length x = List.length x) } { val := y, property := hy }))
    i =   do
  let __do_lift ← List.get? (Vector.toList { val := x, property := (_ : List.length x = List.length x) }) i
  let __do_lift_1 ← List.get? (Vector.toList { val := y, property := hy }) i
  pure (__do_lift && __do_lift_1)
n: β„•

x, y: Bitvec n

i: β„•

List.get? (Vector.toList (Bitvec.and x y)) i = do
  let __do_lift ← List.get? (Vector.toList x) i
  let __do_lift_1 ← List.get? (Vector.toList y) i
  pure (__do_lift && __do_lift_1)
i: β„•

x, y: List Bool

hy: List.length y = List.length x

mk.mk
(Option.bind (Option.map and (List.get? x i)) fun g => Option.map g (List.get? y i)) = do
  let __do_lift ← List.get? x i
  let __do_lift_1 ← List.get? y i
  pure (__do_lift && __do_lift_1)
n: β„•

x, y: Bitvec n

i: β„•

List.get? (Vector.toList (Bitvec.and x y)) i = do
  let __do_lift ← List.get? (Vector.toList x) i
  let __do_lift_1 ← List.get? (Vector.toList y) i
  pure (__do_lift && __do_lift_1)
i: β„•

x, y: List Bool

hy: List.length y = List.length x

mk.mk.none
(Option.bind (Option.map and none) fun g => Option.map g (List.get? y i)) = do
  let __do_lift ← none
  let __do_lift_1 ← List.get? y i
  pure (__do_lift && __do_lift_1)
i: β„•

x, y: List Bool

hy: List.length y = List.length x

val✝: Bool

mk.mk.some
(Option.bind (Option.map and (some val✝)) fun g => Option.map g (List.get? y i)) = do
  let __do_lift ← some val✝
  let __do_lift_1 ← List.get? y i
  pure (__do_lift && __do_lift_1)
i: β„•

x, y: List Bool

hy: List.length y = List.length x

mk.mk
(Option.bind (Option.map and (List.get? x i)) fun g => Option.map g (List.get? y i)) = do
  let __do_lift ← List.get? x i
  let __do_lift_1 ← List.get? y i
  pure (__do_lift && __do_lift_1)
i: β„•

x, y: List Bool

hy: List.length y = List.length x

mk.mk.none
(Option.bind (Option.map and none) fun g => Option.map g (List.get? y i)) = do
  let __do_lift ← none
  let __do_lift_1 ← List.get? y i
  pure (__do_lift && __do_lift_1)
i: β„•

x, y: List Bool

hy: List.length y = List.length x

val✝: Bool

mk.mk.some
(Option.bind (Option.map and (some val✝)) fun g => Option.map g (List.get? y i)) = do
  let __do_lift ← some val✝
  let __do_lift_1 ← List.get? y i
  pure (__do_lift && __do_lift_1)
i: β„•

x, y: List Bool

hy: List.length y = List.length x

mk.mk
(Option.bind (Option.map and (List.get? x i)) fun g => Option.map g (List.get? y i)) = do
  let __do_lift ← List.get? x i
  let __do_lift_1 ← List.get? y i
  pure (__do_lift && __do_lift_1)
i: β„•

x, y: List Bool

hy: List.length y = List.length x

mk.mk.none.none
(Option.bind (Option.map and none) fun g => Option.map g none) = do
  let __do_lift ← none
  let __do_lift_1 ← none
  pure (__do_lift && __do_lift_1)
i: β„•

x, y: List Bool

hy: List.length y = List.length x

val✝: Bool

mk.mk.none.some
(Option.bind (Option.map and none) fun g => Option.map g (some val✝)) = do
  let __do_lift ← none
  let __do_lift_1 ← some val✝
  pure (__do_lift && __do_lift_1)
i: β„•

x, y: List Bool

hy: List.length y = List.length x

mk.mk
(Option.bind (Option.map and (List.get? x i)) fun g => Option.map g (List.get? y i)) = do
  let __do_lift ← List.get? x i
  let __do_lift_1 ← List.get? y i
  pure (__do_lift && __do_lift_1)
i: β„•

x, y: List Bool

hy: List.length y = List.length x

mk.mk.none.none
(Option.bind (Option.map and none) fun g => Option.map g none) = do
  let __do_lift ← none
  let __do_lift_1 ← none
  pure (__do_lift && __do_lift_1)
i: β„•

x, y: List Bool

hy: List.length y = List.length x

val✝: Bool

mk.mk.none.some
(Option.bind (Option.map and none) fun g => Option.map g (some val✝)) = do
  let __do_lift ← none
  let __do_lift_1 ← some val✝
  pure (__do_lift && __do_lift_1)
i: β„•

x, y: List Bool

hy: List.length y = List.length x

val✝: Bool

mk.mk.some.none
(Option.bind (Option.map and (some val✝)) fun g => Option.map g none) = do
  let __do_lift ← some val✝
  let __do_lift_1 ← none
  pure (__do_lift && __do_lift_1)
i: β„•

x, y: List Bool

hy: List.length y = List.length x

val✝¹, val✝: Bool

mk.mk.some.some
(Option.bind (Option.map and (some val✝¹)) fun g => Option.map g (some val✝)) = do
  let __do_lift ← some val✝¹
  let __do_lift_1 ← some val✝
  pure (__do_lift && __do_lift_1)
i: β„•

x, y: List Bool

hy: List.length y = List.length x

mk.mk
(Option.bind (Option.map and (List.get? x i)) fun g => Option.map g (List.get? y i)) = do
  let __do_lift ← List.get? x i
  let __do_lift_1 ← List.get? y i
  pure (__do_lift && __do_lift_1)
Goals accomplished! πŸ™


theorem 
get?_ofInt_neg_one: βˆ€ {w i : β„•}, List.get? (Vector.toList (Bitvec.ofInt w (-1))) i = if i ≀ w then some true else none
get?_ofInt_neg_one : (
Bitvec.ofInt: (n : β„•) β†’ β„€ β†’ Bitvec (Nat.succ n)
Bitvec.ofInt 
w: ?m.313213
w (-
1: ?m.313262
1)).
toList: {Ξ± : Type ?u.313279} β†’ {n : β„•} β†’ Vector Ξ± n β†’ List Ξ±
toList.
get?: {Ξ± : Type ?u.313282} β†’ List Ξ± β†’ β„• β†’ Option Ξ±
get? 
i: ?m.313256
i = 
    if 
i: ?m.313256
i ≀ 
w: ?m.313213
w then 
some: {Ξ± : Type ?u.313305} β†’ Ξ± β†’ Option Ξ±
some 
true: Bool
true else 
none: {Ξ± : Type ?u.313308} β†’ Option Ξ±
none := 
Goals accomplished! πŸ™
w, i: β„•

List.get? (Vector.toList (Bitvec.ofInt w (-1))) i = if i ≀ w then some true else none
w, i: β„•

List.get? (Vector.toList (true ::α΅₯ Bitvec.not (Bitvec.ofNat w 0))) i = if i ≀ w then some true else none
w, i: β„•

List.get? (Vector.toList (Bitvec.ofInt w (-1))) i = if i ≀ w then some true else none
w, i: β„•

List.get? (true :: List.replicate w true) i = if i ≀ w then some true else none
w, i: β„•

List.get? (Vector.toList (Bitvec.ofInt w (-1))) i = if i ≀ w then some true else none
w, i: β„•

List.get? (true :: List.replicate w true) i = if i ≀ w then some true else none
w, i: β„•

List.get? (List.replicate (w + 1) true) i = if i ≀ w then some true else none
w, i: β„•

List.get? (List.replicate (w + 1) true) i = if i ≀ w then some true else none
w, i: β„•

List.get? (Vector.toList (Bitvec.ofInt w (-1))) i = if i ≀ w then some true else none
w, i: β„•

h: i ≀ w

inl
List.get? (List.replicate (w + 1) true) i = some true
w, i: β„•

h: Β¬i ≀ w

inr
List.get? (List.replicate (w + 1) true) i = none
w, i: β„•

List.get? (Vector.toList (Bitvec.ofInt w (-1))) i = if i ≀ w then some true else none
w, i: β„•

h: i ≀ w

inl
List.get? (List.replicate (w + 1) true) i = some true
w, i: β„•

h: i ≀ w

inl
List.get? (List.replicate (w + 1) true) i = some true
w, i: β„•

h: Β¬i ≀ w

inr
List.get? (List.replicate (w + 1) true) i = none
w, i: β„•

h: i ≀ w

inl
List.get? (List.replicate (w + 1) true) i = some true
w, i: β„•

h: i ≀ w

inl
some (List.get (List.replicate (w + 1) true) { val := i, isLt := ?inl }) = some true
w, i: β„•

h: i ≀ w

inl
i < List.length (List.replicate (w + 1) true)
w, i: β„•

h: i ≀ w

inl
List.get? (List.replicate (w + 1) true) i = some true
w, i: β„•

h: i ≀ w

inl
some true = some true
w, i: β„•

h: i ≀ w

inl
i < List.length (List.replicate (w + 1) true)
w, i: β„•

h: i ≀ w

inl
i < List.length (List.replicate (w + 1) true)
w, i: β„•

h: i ≀ w

inl
i < List.length (List.replicate (w + 1) true)
w, i: β„•

h: i ≀ w

inl
i < List.length (List.replicate (w + 1) true)
w, i: β„•

h: i ≀ w

inl
List.get? (List.replicate (w + 1) true) i = some true
w, i: β„•

h: i ≀ w

inl
i < List.length (List.replicate (w + 1) true)
w, i: β„•

h: i ≀ w

inl
i < List.length (List.replicate (w + 1) true)
w, i: β„•

h: i ≀ w

inl
List.get? (List.replicate (w + 1) true) i = some true
Goals accomplished! πŸ™
w, i: β„•

h: Β¬i ≀ w

inr
List.get? (List.replicate (w + 1) true) i = none
w, i: β„•

List.get? (Vector.toList (Bitvec.ofInt w (-1))) i = if i ≀ w then some true else none
w, i: β„•

h: Β¬i ≀ w

inr
List.get? (List.replicate (w + 1) true) i = none
w, i: β„•

h: Β¬i ≀ w

inr
List.get? (List.replicate (w + 1) true) i = none
w, i: β„•

h: Β¬i ≀ w

inr
List.get? (List.replicate (w + 1) true) i = none
w, i: β„•

h: Β¬i ≀ w

inr
List.length (List.replicate (w + 1) true) ≀ i
w, i: β„•

h: Β¬i ≀ w

inr
List.length (List.replicate (w + 1) true) ≀ i
w, i: β„•

h: Β¬i ≀ w

inr
List.get? (List.replicate (w + 1) true) i = none
Goals accomplished! πŸ™
Goals accomplished! πŸ™


-- from InstCombine/Shift:279
theorem 
shl_ushr_eq_and_shl: βˆ€ {w : β„•} {x C : Bitvec (Nat.succ w)},
  shl (ushr x (Bitvec.toNat C)) (Bitvec.toNat C) = Bitvec.and x (shl (Bitvec.ofInt w (-1)) (Bitvec.toNat C))
shl_ushr_eq_and_shl {
w: β„•
w : 
Nat: Type
Nat} {
x: Bitvec (Nat.succ w)
x 
C: Bitvec (Nat.succ w)
C : 
Bitvec: β„• β†’ Type
Bitvec 
w: β„•
w.
succ: β„• β†’ β„•
succ} :
    
Bitvec.shl: {n : β„•} β†’ Bitvec n β†’ β„• β†’ Bitvec n
Bitvec.shl (
Bitvec.ushr: {n : β„•} β†’ Bitvec n β†’ β„• β†’ Bitvec n
Bitvec.ushr 
x: Bitvec (Nat.succ w)
x 
C: Bitvec (Nat.succ w)
C.
toNat: {n : β„•} β†’ Bitvec n β†’ β„•
toNat) 
C: Bitvec (Nat.succ w)
C.
toNat: {n : β„•} β†’ Bitvec n β†’ β„•
toNat = 
Bitvec.and: {n : β„•} β†’ Bitvec n β†’ Bitvec n β†’ Bitvec n
Bitvec.and 
x: Bitvec (Nat.succ w)
x (
Bitvec.shl: {n : β„•} β†’ Bitvec n β†’ β„• β†’ Bitvec n
Bitvec.shl (
Bitvec.ofInt: (n : β„•) β†’ β„€ β†’ Bitvec (Nat.succ n)
Bitvec.ofInt 
w: β„•
w (-
1: ?m.316004
1)) 
C: Bitvec (Nat.succ w)
C.
toNat: {n : β„•} β†’ Bitvec n β†’ β„•
toNat) := 
Goals accomplished! πŸ™
w: β„•

x, C: Bitvec (Nat.succ w)

shl (ushr x (Bitvec.toNat C)) (Bitvec.toNat C) = Bitvec.and x (shl (Bitvec.ofInt w (-1)) (Bitvec.toNat C))
w: β„•

x, C: Bitvec (Nat.succ w)

h
βˆ€ (i : β„•),
  List.get? (Vector.toList (shl (ushr x (Bitvec.toNat C)) (Bitvec.toNat C))) i =     List.get? (Vector.toList (Bitvec.and x (shl (Bitvec.ofInt w (-1)) (Bitvec.toNat C)))) i
w: β„•

x, C: Bitvec (Nat.succ w)

shl (ushr x (Bitvec.toNat C)) (Bitvec.toNat C) = Bitvec.and x (shl (Bitvec.ofInt w (-1)) (Bitvec.toNat C))
w: β„•

x, C: Bitvec (Nat.succ w)

i: β„•

h
List.get? (Vector.toList (shl (ushr x (Bitvec.toNat C)) (Bitvec.toNat C))) i =   List.get? (Vector.toList (Bitvec.and x (shl (Bitvec.ofInt w (-1)) (Bitvec.toNat C)))) i
w: β„•

x, C: Bitvec (Nat.succ w)

shl (ushr x (Bitvec.toNat C)) (Bitvec.toNat C) = Bitvec.and x (shl (Bitvec.ofInt w (-1)) (Bitvec.toNat C))
w: β„•

x, C: Bitvec (Nat.succ w)

i: β„•

h
List.get? (Vector.toList (shl (ushr x (Bitvec.toNat C)) (Bitvec.toNat C))) i =   List.get? (Vector.toList (Bitvec.and x (shl (Bitvec.ofInt w (-1)) (Bitvec.toNat C)))) i
w: β„•

x, C: Bitvec (Nat.succ w)

i: β„•

h
(if Bitvec.toNat C + i < Nat.succ w then List.get? (Vector.toList (ushr x (Bitvec.toNat C))) (Bitvec.toNat C + i)
  else if i < Nat.succ w then some false else none) =   List.get? (Vector.toList (Bitvec.and x (shl (Bitvec.ofInt w (-1)) (Bitvec.toNat C)))) i
w: β„•

x, C: Bitvec (Nat.succ w)

i: β„•

h
List.get? (Vector.toList (shl (ushr x (Bitvec.toNat C)) (Bitvec.toNat C))) i =   List.get? (Vector.toList (Bitvec.and x (shl (Bitvec.ofInt w (-1)) (Bitvec.toNat C)))) i
w: β„•

x, C: Bitvec (Nat.succ w)

i: β„•

h
(if Bitvec.toNat C + i < Nat.succ w then
    if Bitvec.toNat C + i < Vector.length x then
      if Bitvec.toNat C + i < Bitvec.toNat C then some false
      else List.get? (Vector.toList x) (Bitvec.toNat C + i - Bitvec.toNat C)
    else none
  else if i < Nat.succ w then some false else none) =   List.get? (Vector.toList (Bitvec.and x (shl (Bitvec.ofInt w (-1)) (Bitvec.toNat C)))) i
w: β„•

x, C: Bitvec (Nat.succ w)

i: β„•

h
List.get? (Vector.toList (shl (ushr x (Bitvec.toNat C)) (Bitvec.toNat C))) i =   List.get? (Vector.toList (Bitvec.and x (shl (Bitvec.ofInt w (-1)) (Bitvec.toNat C)))) i
w: β„•

x, C: Bitvec (Nat.succ w)

i: β„•

h
(if Bitvec.toNat C + i < Nat.succ w then
    if Bitvec.toNat C + i < Vector.length x then
      if Bitvec.toNat C + i < Bitvec.toNat C then some false
      else List.get? (Vector.toList x) (Bitvec.toNat C + i - Bitvec.toNat C)
    else none
  else if i < Nat.succ w then some false else none) =   do
  let __do_lift ← List.get? (Vector.toList x) i
  let __do_lift_1 ← List.get? (Vector.toList (shl (Bitvec.ofInt w (-1)) (Bitvec.toNat C))) i
  pure (__do_lift && __do_lift_1)
w: β„•

x, C: Bitvec (Nat.succ w)

i: β„•

h
(if Bitvec.toNat C + i < Nat.succ w then
    if Bitvec.toNat C + i < Vector.length x then
      if Bitvec.toNat C + i < Bitvec.toNat C then some false
      else List.get? (Vector.toList x) (Bitvec.toNat C + i - Bitvec.toNat C)
    else none
  else if i < Nat.succ w then some false else none) =   do
  let __do_lift ← List.get? (Vector.toList x) i
  let __do_lift_1 ← List.get? (Vector.toList (shl (Bitvec.ofInt w (-1)) (Bitvec.toNat C))) i
  pure (__do_lift && __do_lift_1)
w: β„•

x, C: Bitvec (Nat.succ w)

shl (ushr x (Bitvec.toNat C)) (Bitvec.toNat C) = Bitvec.and x (shl (Bitvec.ofInt w (-1)) (Bitvec.toNat C))
w: β„•

x, C: Bitvec (Nat.succ w)

i: β„•

h
(if Bitvec.toNat C + i ≀ w then
    if Bitvec.toNat C + i ≀ w then
      if Bitvec.toNat C + i < Bitvec.toNat C then some false
      else List.get? (Vector.toList x) (Bitvec.toNat C + i - Bitvec.toNat C)
    else none
  else if i ≀ w then some false else none) =   Option.bind (List.get? (Vector.toList x) i) fun __do_lift =>
    Option.bind
      (if Bitvec.toNat C + i ≀ w then if Bitvec.toNat C + i ≀ w then some true else none
      else if i ≀ w then some false else none)
      fun __do_lift_1 => some (__do_lift && __do_lift_1)
w: β„•

x, C: Bitvec (Nat.succ w)

shl (ushr x (Bitvec.toNat C)) (Bitvec.toNat C) = Bitvec.and x (shl (Bitvec.ofInt w (-1)) (Bitvec.toNat C))
w: β„•

x, C: Bitvec (Nat.succ w)

i: β„•

h₁: Bitvec.toNat C + i ≀ w

hβ‚‚: Bitvec.toNat C + i < Bitvec.toNat C

h.inl.inl
some false =   Option.bind (List.get? (Vector.toList x) i) fun __do_lift =>
    Option.bind (some true) fun __do_lift_1 => some (__do_lift && __do_lift_1)
w: β„•

x, C: Bitvec (Nat.succ w)

i: β„•

h₁: Bitvec.toNat C + i ≀ w

hβ‚‚: Β¬Bitvec.toNat C + i < Bitvec.toNat C

h.inl.inr
List.get? (Vector.toList x) (Bitvec.toNat C + i - Bitvec.toNat C) =   Option.bind (List.get? (Vector.toList x) i) fun __do_lift =>
    Option.bind (some true) fun __do_lift_1 => some (__do_lift && __do_lift_1)
w: β„•

x, C: Bitvec (Nat.succ w)

i: β„•

h₁: Β¬Bitvec.toNat C + i ≀ w

h₃: i ≀ w

h.inr.inl
some false =   Option.bind (List.get? (Vector.toList x) i) fun __do_lift =>
    Option.bind (some false) fun __do_lift_1 => some (__do_lift && __do_lift_1)
w: β„•

x, C: Bitvec (Nat.succ w)

i: β„•

h₁: Β¬Bitvec.toNat C + i ≀ w

h₃: Β¬i ≀ w

h.inr.inr
none =   Option.bind (List.get? (Vector.toList x) i) fun __do_lift =>
    Option.bind none fun __do_lift_1 => some (__do_lift && __do_lift_1)
w: β„•

x, C: Bitvec (Nat.succ w)

shl (ushr x (Bitvec.toNat C)) (Bitvec.toNat C) = Bitvec.and x (shl (Bitvec.ofInt w (-1)) (Bitvec.toNat C))
w: β„•

x, C: Bitvec (Nat.succ w)

i: β„•

h₁: Bitvec.toNat C + i ≀ w

hβ‚‚: Bitvec.toNat C + i < Bitvec.toNat C

h.inl.inl
some false =   Option.bind (List.get? (Vector.toList x) i) fun __do_lift =>
    Option.bind (some true) fun __do_lift_1 => some (__do_lift && __do_lift_1)
w: β„•

x, C: Bitvec (Nat.succ w)

i: β„•

h₁: Bitvec.toNat C + i ≀ w

hβ‚‚: Bitvec.toNat C + i < Bitvec.toNat C

h.inl.inl
some false =   Option.bind (List.get? (Vector.toList x) i) fun __do_lift =>
    Option.bind (some true) fun __do_lift_1 => some (__do_lift && __do_lift_1)
w: β„•

x, C: Bitvec (Nat.succ w)

i: β„•

h₁: Bitvec.toNat C + i ≀ w

hβ‚‚: Β¬Bitvec.toNat C + i < Bitvec.toNat C

h.inl.inr
List.get? (Vector.toList x) (Bitvec.toNat C + i - Bitvec.toNat C) =   Option.bind (List.get? (Vector.toList x) i) fun __do_lift =>
    Option.bind (some true) fun __do_lift_1 => some (__do_lift && __do_lift_1)
w: β„•

x, C: Bitvec (Nat.succ w)

i: β„•

h₁: Β¬Bitvec.toNat C + i ≀ w

h₃: i ≀ w

h.inr.inl
some false =   Option.bind (List.get? (Vector.toList x) i) fun __do_lift =>
    Option.bind (some false) fun __do_lift_1 => some (__do_lift && __do_lift_1)
w: β„•

x, C: Bitvec (Nat.succ w)

i: β„•

h₁: Β¬Bitvec.toNat C + i ≀ w

h₃: Β¬i ≀ w

h.inr.inr
none =   Option.bind (List.get? (Vector.toList x) i) fun __do_lift =>
    Option.bind none fun __do_lift_1 => some (__do_lift && __do_lift_1)
Goals accomplished! πŸ™
w: β„•

x, C: Bitvec (Nat.succ w)

i: β„•

h₁: Bitvec.toNat C + i ≀ w

hβ‚‚: Β¬Bitvec.toNat C + i < Bitvec.toNat C

h.inl.inr
List.get? (Vector.toList x) (Bitvec.toNat C + i - Bitvec.toNat C) =   Option.bind (List.get? (Vector.toList x) i) fun __do_lift =>
    Option.bind (some true) fun __do_lift_1 => some (__do_lift && __do_lift_1)
w: β„•

x, C: Bitvec (Nat.succ w)

i: β„•

h₁: Β¬Bitvec.toNat C + i ≀ w

h₃: i ≀ w

h.inr.inl
some false =   Option.bind (List.get? (Vector.toList x) i) fun __do_lift =>
    Option.bind (some false) fun __do_lift_1 => some (__do_lift && __do_lift_1)
w: β„•

x, C: Bitvec (Nat.succ w)

i: β„•

h₁: Β¬Bitvec.toNat C + i ≀ w

h₃: Β¬i ≀ w

h.inr.inr
none =   Option.bind (List.get? (Vector.toList x) i) fun __do_lift =>
    Option.bind none fun __do_lift_1 => some (__do_lift && __do_lift_1)
w: β„•

x, C: Bitvec (Nat.succ w)

shl (ushr x (Bitvec.toNat C)) (Bitvec.toNat C) = Bitvec.and x (shl (Bitvec.ofInt w (-1)) (Bitvec.toNat C))
w: β„•

x, C: Bitvec (Nat.succ w)

i: β„•

h₁: Bitvec.toNat C + i ≀ w

hβ‚‚: Β¬Bitvec.toNat C + i < Bitvec.toNat C

h.inl.inr
List.get? (Vector.toList x) (Bitvec.toNat C + i - Bitvec.toNat C) =   Option.bind (List.get? (Vector.toList x) i) fun __do_lift =>
    Option.bind (some true) fun __do_lift_1 => some (__do_lift && __do_lift_1)
w: β„•

x, C: Bitvec (Nat.succ w)

i: β„•

h₁: Bitvec.toNat C + i ≀ w

hβ‚‚: Β¬Bitvec.toNat C + i < Bitvec.toNat C

h.inl.inr
List.get? (Vector.toList x) (Bitvec.toNat C + i - Bitvec.toNat C) =   Option.bind (List.get? (Vector.toList x) i) fun __do_lift =>
    Option.bind (some true) fun __do_lift_1 => some (__do_lift && __do_lift_1)
w: β„•

x, C: Bitvec (Nat.succ w)

i: β„•

h₁: Β¬Bitvec.toNat C + i ≀ w

h₃: i ≀ w

h.inr.inl
some false =   Option.bind (List.get? (Vector.toList x) i) fun __do_lift =>
    Option.bind (some false) fun __do_lift_1 => some (__do_lift && __do_lift_1)
w: β„•

x, C: Bitvec (Nat.succ w)

i: β„•

h₁: Β¬Bitvec.toNat C + i ≀ w

h₃: Β¬i ≀ w

h.inr.inr
none =   Option.bind (List.get? (Vector.toList x) i) fun __do_lift =>
    Option.bind none fun __do_lift_1 => some (__do_lift && __do_lift_1)
Goals accomplished! πŸ™
w: β„•

x, C: Bitvec (Nat.succ w)

i: β„•

h₁: Β¬Bitvec.toNat C + i ≀ w

h₃: i ≀ w

h.inr.inl
some false =   Option.bind (List.get? (Vector.toList x) i) fun __do_lift =>
    Option.bind (some false) fun __do_lift_1 => some (__do_lift && __do_lift_1)
w: β„•

x, C: Bitvec (Nat.succ w)

i: β„•

h₁: Β¬Bitvec.toNat C + i ≀ w

h₃: Β¬i ≀ w

h.inr.inr
none =   Option.bind (List.get? (Vector.toList x) i) fun __do_lift =>
    Option.bind none fun __do_lift_1 => some (__do_lift && __do_lift_1)
w: β„•

x, C: Bitvec (Nat.succ w)

shl (ushr x (Bitvec.toNat C)) (Bitvec.toNat C) = Bitvec.and x (shl (Bitvec.ofInt w (-1)) (Bitvec.toNat C))
w: β„•

x, C: Bitvec (Nat.succ w)

i: β„•

h₁: Β¬Bitvec.toNat C + i ≀ w

h₃: i ≀ w

h.inr.inl
some false =   Option.bind (List.get? (Vector.toList x) i) fun __do_lift =>
    Option.bind (some false) fun __do_lift_1 => some (__do_lift && __do_lift_1)
w: β„•

x, C: Bitvec (Nat.succ w)

i: β„•

h₁: Β¬Bitvec.toNat C + i ≀ w

h₃: i ≀ w

h.inr.inl
some false =   Option.bind (List.get? (Vector.toList x) i) fun __do_lift =>
    Option.bind (some false) fun __do_lift_1 => some (__do_lift && __do_lift_1)
w: β„•

x, C: Bitvec (Nat.succ w)

i: β„•

h₁: Β¬Bitvec.toNat C + i ≀ w

h₃: Β¬i ≀ w

h.inr.inr
none =   Option.bind (List.get? (Vector.toList x) i) fun __do_lift =>
    Option.bind none fun __do_lift_1 => some (__do_lift && __do_lift_1)
w: β„•

x, C: Bitvec (Nat.succ w)

i: β„•

h₁: Β¬Bitvec.toNat C + i ≀ w

h₃: i ≀ w

h.inr.inl
some false =   Option.bind (List.get? (Vector.toList x) i) fun __do_lift =>
    Option.bind (some false) fun __do_lift_1 => some (__do_lift && __do_lift_1)
w: β„•

x, C: Bitvec (Nat.succ w)

i: β„•

h₁: Β¬Bitvec.toNat C + i ≀ w

h₃: i ≀ w

h.inr.inl
some false =   Option.bind (some (List.get (Vector.toList x) { val := i, isLt := ?h.inr.inl })) fun __do_lift =>
    Option.bind (some false) fun __do_lift_1 => some (__do_lift && __do_lift_1)
w: β„•

x, C: Bitvec (Nat.succ w)

i: β„•

h₁: Β¬Bitvec.toNat C + i ≀ w

h₃: i ≀ w

h.inr.inl
i < List.length (Vector.toList x)
w: β„•

x, C: Bitvec (Nat.succ w)

i: β„•

h₁: Β¬Bitvec.toNat C + i ≀ w

h₃: i ≀ w

h.inr.inl
some false =   Option.bind (some (List.get (Vector.toList x) { val := i, isLt := ?h.inr.inl })) fun __do_lift =>
    Option.bind (some false) fun __do_lift_1 => some (__do_lift && __do_lift_1)
w: β„•

x, C: Bitvec (Nat.succ w)

i: β„•

h₁: Β¬Bitvec.toNat C + i ≀ w

h₃: i ≀ w

h.inr.inl
i < List.length (Vector.toList x)
w: β„•

x, C: Bitvec (Nat.succ w)

i: β„•

h₁: Β¬Bitvec.toNat C + i ≀ w

h₃: i ≀ w

h.inr.inl
some false =   Option.bind (List.get? (Vector.toList x) i) fun __do_lift =>
    Option.bind (some false) fun __do_lift_1 => some (__do_lift && __do_lift_1)
w: β„•

x, C: Bitvec (Nat.succ w)

i: β„•

h₁: Β¬Bitvec.toNat C + i ≀ w

h₃: i ≀ w

h.inr.inl
some false =   Option.bind (some (List.get (Vector.toList x) { val := i, isLt := ?h.inr.inl })) fun __do_lift =>
    Option.bind (some false) fun __do_lift_1 => some (__do_lift && __do_lift_1)
w: β„•

x, C: Bitvec (Nat.succ w)

i: β„•

h₁: Β¬Bitvec.toNat C + i ≀ w

h₃: i ≀ w

h.inr.inl
i < List.length (Vector.toList x)
w: β„•

x, C: Bitvec (Nat.succ w)

i: β„•

h₁: Β¬Bitvec.toNat C + i ≀ w

h₃: i ≀ w

h.inr.inl
some false =   Option.bind (List.get? (Vector.toList x) i) fun __do_lift =>
    Option.bind (some false) fun __do_lift_1 => some (__do_lift && __do_lift_1)
Goals accomplished! πŸ™
w: β„•

x, C: Bitvec (Nat.succ w)

i: β„•

h₁: Β¬Bitvec.toNat C + i ≀ w

h₃: Β¬i ≀ w

h.inr.inr
none =   Option.bind (List.get? (Vector.toList x) i) fun __do_lift =>
    Option.bind none fun __do_lift_1 => some (__do_lift && __do_lift_1)
w: β„•

x, C: Bitvec (Nat.succ w)

shl (ushr x (Bitvec.toNat C)) (Bitvec.toNat C) = Bitvec.and x (shl (Bitvec.ofInt w (-1)) (Bitvec.toNat C))
w: β„•

x, C: Bitvec (Nat.succ w)

i: β„•

h₁: Β¬Bitvec.toNat C + i ≀ w

h₃: Β¬i ≀ w

h.inr.inr
none =   Option.bind (List.get? (Vector.toList x) i) fun __do_lift =>
    Option.bind none fun __do_lift_1 => some (__do_lift && __do_lift_1)
w: β„•

x, C: Bitvec (Nat.succ w)

i: β„•

h₁: Β¬Bitvec.toNat C + i ≀ w

h₃: Β¬i ≀ w

h.inr.inr
none =   Option.bind (List.get? (Vector.toList x) i) fun __do_lift =>
    Option.bind none fun __do_lift_1 => some (__do_lift && __do_lift_1)
w: β„•

x, C: Bitvec (Nat.succ w)

i: β„•

h₁: Β¬Bitvec.toNat C + i ≀ w

h₃: Β¬i ≀ w

h.inr.inr
none =   Option.bind (List.get? (Vector.toList x) i) fun __do_lift =>
    Option.bind none fun __do_lift_1 => some (__do_lift && __do_lift_1)
w: β„•

x, C: Bitvec (Nat.succ w)

i: β„•

h₁: Β¬Bitvec.toNat C + i ≀ w

h₃: Β¬i ≀ w

h.inr.inr
none = Option.bind none fun __do_lift => Option.bind none fun __do_lift_1 => some (__do_lift && __do_lift_1)
w: β„•

x, C: Bitvec (Nat.succ w)

i: β„•

h₁: Β¬Bitvec.toNat C + i ≀ w

h₃: Β¬i ≀ w

h.inr.inr
List.length (Vector.toList x) ≀ i
w: β„•

x, C: Bitvec (Nat.succ w)

i: β„•

h₁: Β¬Bitvec.toNat C + i ≀ w

h₃: Β¬i ≀ w

h.inr.inr
none = Option.bind none fun __do_lift => Option.bind none fun __do_lift_1 => some (__do_lift && __do_lift_1)
w: β„•

x, C: Bitvec (Nat.succ w)

i: β„•

h₁: Β¬Bitvec.toNat C + i ≀ w

h₃: Β¬i ≀ w

h.inr.inr
List.length (Vector.toList x) ≀ i
w: β„•

x, C: Bitvec (Nat.succ w)

i: β„•

h₁: Β¬Bitvec.toNat C + i ≀ w

h₃: Β¬i ≀ w

h.inr.inr
none =   Option.bind (List.get? (Vector.toList x) i) fun __do_lift =>
    Option.bind none fun __do_lift_1 => some (__do_lift && __do_lift_1)
w: β„•

x, C: Bitvec (Nat.succ w)

i: β„•

h₁: Β¬Bitvec.toNat C + i ≀ w

h₃: Β¬i ≀ w

h.inr.inr
none = Option.bind none fun __do_lift => Option.bind none fun __do_lift_1 => some (__do_lift && __do_lift_1)
w: β„•

x, C: Bitvec (Nat.succ w)

i: β„•

h₁: Β¬Bitvec.toNat C + i ≀ w

h₃: Β¬i ≀ w

h.inr.inr
List.length (Vector.toList x) ≀ i
w: β„•

x, C: Bitvec (Nat.succ w)

i: β„•

h₁: Β¬Bitvec.toNat C + i ≀ w

h₃: Β¬i ≀ w

h.inr.inr
none =   Option.bind (List.get? (Vector.toList x) i) fun __do_lift =>
    Option.bind none fun __do_lift_1 => some (__do_lift && __do_lift_1)
Goals accomplished! πŸ™
w: β„•

x, C: Bitvec (Nat.succ w)

i: β„•

h₁: w < Bitvec.toNat C + i

h₃: w < i

h.inr.inr
w < i
w: β„•

x, C: Bitvec (Nat.succ w)

i: β„•

h₁: Β¬Bitvec.toNat C + i ≀ w

h₃: Β¬i ≀ w

h.inr.inr
none =   Option.bind (List.get? (Vector.toList x) i) fun __do_lift =>
    Option.bind none fun __do_lift_1 => some (__do_lift && __do_lift_1)
Goals accomplished! πŸ™
Goals accomplished! πŸ™


theorem 
toInt_injective: βˆ€ {w : β„•}, Function.Injective Bitvec.toInt
toInt_injective : βˆ€ {
w: β„•
w : 
Nat: Type
Nat}, 
Function.Injective: {Ξ± : Sort ?u.331618} β†’ {Ξ² : Sort ?u.331617} β†’ (Ξ± β†’ Ξ²) β†’ Prop
Function.Injective (
Bitvec.toInt: {n : β„•} β†’ Bitvec n β†’ β„€
Bitvec.toInt : 
Bitvec: β„• β†’ Type
Bitvec 
w: β„•
w β†’ 
β„€: Type
β„€)
  | 
0: β„•
0, ⟨[], 
_: List.length [] = 0
_⟩, ⟨[], _⟩, 
rfl: βˆ€ {Ξ± : Sort ?u.331651} {a : Ξ±}, a = a
rfl => 
rfl: βˆ€ {Ξ± : Sort ?u.331746} {a : Ξ±}, a = a
rfl
  | 
n: β„•
n+
1: β„•
1, ⟨
a: Bool
a::
x: List Bool
x, 
hx: List.length (a :: x) = n + 1
hx⟩, ⟨
b: Bool
b::
y: List Bool
y, 
hy: List.length (b :: y) = n + 1
hy⟩, 
h: Bitvec.toInt { val := a :: x, property := hx } = Bitvec.toInt { val := b :: y, property := hy }
h => 
Goals accomplished! πŸ™
n: β„•

a: Bool

x: List Bool

hx: List.length (a :: x) = n + 1

b: Bool

y: List Bool

hy: List.length (b :: y) = n + 1

h: Bitvec.toInt { val := a :: x, property := hx } = Bitvec.toInt { val := b :: y, property := hy }

{ val := a :: x, property := hx } = { val := b :: y, property := hy }
n: β„•

a: Bool

x: List Bool

hx: List.length (a :: x) = n + 1

b: Bool

y: List Bool

hy: List.length (b :: y) = n + 1

h: (bif a then Int.negSucc (Bitvec.toNat (Bitvec.not (Vector.tail { val := a :: x, property := hx })))
  else ↑(Bitvec.toNat (Vector.tail { val := a :: x, property := hx }))) =   bif b then Int.negSucc (Bitvec.toNat (Bitvec.not (Vector.tail { val := b :: y, property := hy })))
  else ↑(Bitvec.toNat (Vector.tail { val := b :: y, property := hy }))

{ val := a :: x, property := hx } = { val := b :: y, property := hy }
n: β„•

a: Bool

x: List Bool

hx: List.length (a :: x) = n + 1

b: Bool

y: List Bool

hy: List.length (b :: y) = n + 1

h: Bitvec.toInt { val := a :: x, property := hx } = Bitvec.toInt { val := b :: y, property := hy }

{ val := a :: x, property := hx } = { val := b :: y, property := hy }
n: β„•

a: Bool

x: List Bool

hx: List.length (a :: x) = n + 1

b: Bool

y: List Bool

hy: List.length (b :: y) = n + 1

h: (bif a then Int.negSucc (Bitvec.toNat (Bitvec.not (Vector.tail { val := a :: x, property := hx })))
  else ↑(Bitvec.toNat (Vector.tail { val := a :: x, property := hx }))) =   bif b then Int.negSucc (Bitvec.toNat (Bitvec.not (Vector.tail { val := b :: y, property := hy })))
  else ↑(Bitvec.toNat (Vector.tail { val := b :: y, property := hy }))

a
Vector.toList { val := a :: x, property := hx } = Vector.toList { val := b :: y, property := hy }
n: β„•

a: Bool

x: List Bool

hx: List.length (a :: x) = n + 1

b: Bool

y: List Bool

hy: List.length (b :: y) = n + 1

h: Bitvec.toInt { val := a :: x, property := hx } = Bitvec.toInt { val := b :: y, property := hy }

{ val := a :: x, property := hx } = { val := b :: y, property := hy }
n: β„•

x: List Bool

b: Bool

y: List Bool

hy: List.length (b :: y) = n + 1

hx: List.length (false :: x) = n + 1

h: (bif false then Int.negSucc (Bitvec.toNat (Bitvec.not (Vector.tail { val := false :: x, property := hx })))
  else ↑(Bitvec.toNat (Vector.tail { val := false :: x, property := hx }))) =   bif b then Int.negSucc (Bitvec.toNat (Bitvec.not (Vector.tail { val := b :: y, property := hy })))
  else ↑(Bitvec.toNat (Vector.tail { val := b :: y, property := hy }))

a.false
Vector.toList { val := false :: x, property := hx } = Vector.toList { val := b :: y, property := hy }
n: β„•

x: List Bool

b: Bool

y: List Bool

hy: List.length (b :: y) = n + 1

hx: List.length (true :: x) = n + 1

h: (bif true then Int.negSucc (Bitvec.toNat (Bitvec.not (Vector.tail { val := true :: x, property := hx })))
  else ↑(Bitvec.toNat (Vector.tail { val := true :: x, property := hx }))) =   bif b then Int.negSucc (Bitvec.toNat (Bitvec.not (Vector.tail { val := b :: y, property := hy })))
  else ↑(Bitvec.toNat (Vector.tail { val := b :: y, property := hy }))

a.true
Vector.toList { val := true :: x, property := hx } = Vector.toList { val := b :: y, property := hy }
n: β„•

a: Bool

x: List Bool

hx: List.length (a :: x) = n + 1

b: Bool

y: List Bool

hy: List.length (b :: y) = n + 1

h: (bif a then Int.negSucc (Bitvec.toNat (Bitvec.not (Vector.tail { val := a :: x, property := hx })))
  else ↑(Bitvec.toNat (Vector.tail { val := a :: x, property := hx }))) =   bif b then Int.negSucc (Bitvec.toNat (Bitvec.not (Vector.tail { val := b :: y, property := hy })))
  else ↑(Bitvec.toNat (Vector.tail { val := b :: y, property := hy }))

a
Vector.toList { val := a :: x, property := hx } = Vector.toList { val := b :: y, property := hy }
n: β„•

x: List Bool

b: Bool

y: List Bool

hy: List.length (b :: y) = n + 1

hx: List.length (false :: x) = n + 1

h: (bif false then Int.negSucc (Bitvec.toNat (Bitvec.not (Vector.tail { val := false :: x, property := hx })))
  else ↑(Bitvec.toNat (Vector.tail { val := false :: x, property := hx }))) =   bif b then Int.negSucc (Bitvec.toNat (Bitvec.not (Vector.tail { val := b :: y, property := hy })))
  else ↑(Bitvec.toNat (Vector.tail { val := b :: y, property := hy }))

a.false
Vector.toList { val := false :: x, property := hx } = Vector.toList { val := b :: y, property := hy }
n: β„•

x: List Bool

b: Bool

y: List Bool

hy: List.length (b :: y) = n + 1

hx: List.length (true :: x) = n + 1

h: (bif true then Int.negSucc (Bitvec.toNat (Bitvec.not (Vector.tail { val := true :: x, property := hx })))
  else ↑(Bitvec.toNat (Vector.tail { val := true :: x, property := hx }))) =   bif b then Int.negSucc (Bitvec.toNat (Bitvec.not (Vector.tail { val := b :: y, property := hy })))
  else ↑(Bitvec.toNat (Vector.tail { val := b :: y, property := hy }))

a.true
Vector.toList { val := true :: x, property := hx } = Vector.toList { val := b :: y, property := hy }
n: β„•

a: Bool

x: List Bool

hx: List.length (a :: x) = n + 1

b: Bool

y: List Bool

hy: List.length (b :: y) = n + 1

h: (bif a then Int.negSucc (Bitvec.toNat (Bitvec.not (Vector.tail { val := a :: x, property := hx })))
  else ↑(Bitvec.toNat (Vector.tail { val := a :: x, property := hx }))) =   bif b then Int.negSucc (Bitvec.toNat (Bitvec.not (Vector.tail { val := b :: y, property := hy })))
  else ↑(Bitvec.toNat (Vector.tail { val := b :: y, property := hy }))

a
Vector.toList { val := a :: x, property := hx } = Vector.toList { val := b :: y, property := hy }
n: β„•

x, y: List Bool

hx: List.length (true :: x) = n + 1

hy: List.length (false :: y) = n + 1

h: (bif true then Int.negSucc (Bitvec.toNat (Bitvec.not (Vector.tail { val := true :: x, property := hx })))
  else ↑(Bitvec.toNat (Vector.tail { val := true :: x, property := hx }))) =   bif false then Int.negSucc (Bitvec.toNat (Bitvec.not (Vector.tail { val := false :: y, property := hy })))
  else ↑(Bitvec.toNat (Vector.tail { val := false :: y, property := hy }))

a.true.false
Vector.toList { val := true :: x, property := hx } = Vector.toList { val := false :: y, property := hy }
n: β„•

x, y: List Bool

hx: List.length (true :: x) = n + 1

hy: List.length (true :: y) = n + 1

h: (bif true then Int.negSucc (Bitvec.toNat (Bitvec.not (Vector.tail { val := true :: x, property := hx })))
  else ↑(Bitvec.toNat (Vector.tail { val := true :: x, property := hx }))) =   bif true then Int.negSucc (Bitvec.toNat (Bitvec.not (Vector.tail { val := true :: y, property := hy })))
  else ↑(Bitvec.toNat (Vector.tail { val := true :: y, property := hy }))

a.true.true
Vector.toList { val := true :: x, property := hx } = Vector.toList { val := true :: y, property := hy }
n: β„•

a: Bool

x: List Bool

hx: List.length (a :: x) = n + 1

b: Bool

y: List Bool

hy: List.length (b :: y) = n + 1

h: Bitvec.toInt { val := a :: x, property := hx } = Bitvec.toInt { val := b :: y, property := hy }

{ val := a :: x, property := hx } = { val := b :: y, property := hy }
n: β„•

x, y: List Bool

hx: List.length (false :: x) = n + 1

hy: List.length (false :: y) = n + 1

h: (bif false then Int.negSucc (Bitvec.toNat (Bitvec.not (Vector.tail { val := false :: x, property := hx })))
  else ↑(Bitvec.toNat (Vector.tail { val := false :: x, property := hx }))) =   bif false then Int.negSucc (Bitvec.toNat (Bitvec.not (Vector.tail { val := false :: y, property := hy })))
  else ↑(Bitvec.toNat (Vector.tail { val := false :: y, property := hy }))

a.false.false
Vector.toList { val := false :: x, property := hx } = Vector.toList { val := false :: y, property := hy }
n: β„•

x, y: List Bool

hx: List.length (false :: x) = n + 1

hy: List.length (false :: y) = n + 1

h: (bif false then Int.negSucc (Bitvec.toNat (Bitvec.not (Vector.tail { val := false :: x, property := hx })))
  else ↑(Bitvec.toNat (Vector.tail { val := false :: x, property := hx }))) =   bif false then Int.negSucc (Bitvec.toNat (Bitvec.not (Vector.tail { val := false :: y, property := hy })))
  else ↑(Bitvec.toNat (Vector.tail { val := false :: y, property := hy }))

a.false.false
Vector.toList { val := false :: x, property := hx } = Vector.toList { val := false :: y, property := hy }
n: β„•

x, y: List Bool

hx: List.length (false :: x) = n + 1

hy: List.length (true :: y) = n + 1

h: (bif false then Int.negSucc (Bitvec.toNat (Bitvec.not (Vector.tail { val := false :: x, property := hx })))
  else ↑(Bitvec.toNat (Vector.tail { val := false :: x, property := hx }))) =   bif true then Int.negSucc (Bitvec.toNat (Bitvec.not (Vector.tail { val := true :: y, property := hy })))
  else ↑(Bitvec.toNat (Vector.tail { val := true :: y, property := hy }))

a.false.true
Vector.toList { val := false :: x, property := hx } = Vector.toList { val := true :: y, property := hy }
n: β„•

x, y: List Bool

hx: List.length (true :: x) = n + 1

hy: List.length (false :: y) = n + 1

h: (bif true then Int.negSucc (Bitvec.toNat (Bitvec.not (Vector.tail { val := true :: x, property := hx })))
  else ↑(Bitvec.toNat (Vector.tail { val := true :: x, property := hx }))) =   bif false then Int.negSucc (Bitvec.toNat (Bitvec.not (Vector.tail { val := false :: y, property := hy })))
  else ↑(Bitvec.toNat (Vector.tail { val := false :: y, property := hy }))

a.true.false
Vector.toList { val := true :: x, property := hx } = Vector.toList { val := false :: y, property := hy }
n: β„•

x, y: List Bool

hx: List.length (true :: x) = n + 1

hy: List.length (true :: y) = n + 1

h: (bif true then Int.negSucc (Bitvec.toNat (Bitvec.not (Vector.tail { val := true :: x, property := hx })))
  else ↑(Bitvec.toNat (Vector.tail { val := true :: x, property := hx }))) =   bif true then Int.negSucc (Bitvec.toNat (Bitvec.not (Vector.tail { val := true :: y, property := hy })))
  else ↑(Bitvec.toNat (Vector.tail { val := true :: y, property := hy }))

a.true.true
Vector.toList { val := true :: x, property := hx } = Vector.toList { val := true :: y, property := hy }
n: β„•

x, y: List Bool

hx: List.length (false :: x) = n + 1

hy: List.length (false :: y) = n + 1

h: Bitvec.toNat { val := x, property := (_ : Nat.pred (List.length (false :: x)) = Nat.pred (Nat.succ (n + 0))) } =   Bitvec.toNat { val := y, property := (_ : Nat.pred (List.length (false :: y)) = Nat.pred (Nat.succ (n + 0))) }

a.false.false
Vector.toList { val := false :: x, property := hx } = Vector.toList { val := false :: y, property := hy }
n: β„•

x, y: List Bool

hx: List.length (false :: x) = n + 1

hy: List.length (false :: y) = n + 1

h: (bif false then Int.negSucc (Bitvec.toNat (Bitvec.not (Vector.tail { val := false :: x, property := hx })))
  else ↑(Bitvec.toNat (Vector.tail { val := false :: x, property := hx }))) =   bif false then Int.negSucc (Bitvec.toNat (Bitvec.not (Vector.tail { val := false :: y, property := hy })))
  else ↑(Bitvec.toNat (Vector.tail { val := false :: y, property := hy }))

a.false.false
Vector.toList { val := false :: x, property := hx } = Vector.toList { val := false :: y, property := hy }
n: β„•

x, y: List Bool

hx: List.length (false :: x) = n + 1

hy: List.length (true :: y) = n + 1

h: (bif false then Int.negSucc (Bitvec.toNat (Bitvec.not (Vector.tail { val := false :: x, property := hx })))
  else ↑(Bitvec.toNat (Vector.tail { val := false :: x, property := hx }))) =   bif true then Int.negSucc (Bitvec.toNat (Bitvec.not (Vector.tail { val := true :: y, property := hy })))
  else ↑(Bitvec.toNat (Vector.tail { val := true :: y, property := hy }))

a.false.true
Vector.toList { val := false :: x, property := hx } = Vector.toList { val := true :: y, property := hy }
n: β„•

x, y: List Bool

hx: List.length (true :: x) = n + 1

hy: List.length (false :: y) = n + 1

h: (bif true then Int.negSucc (Bitvec.toNat (Bitvec.not (Vector.tail { val := true :: x, property := hx })))
  else ↑(Bitvec.toNat (Vector.tail { val := true :: x, property := hx }))) =   bif false then Int.negSucc (Bitvec.toNat (Bitvec.not (Vector.tail { val := false :: y, property := hy })))
  else ↑(Bitvec.toNat (Vector.tail { val := false :: y, property := hy }))

a.true.false
Vector.toList { val := true :: x, property := hx } = Vector.toList { val := false :: y, property := hy }
n: β„•

x, y: List Bool

hx: List.length (true :: x) = n + 1

hy: List.length (true :: y) = n + 1

h: (bif true then Int.negSucc (Bitvec.toNat (Bitvec.not (Vector.tail { val := true :: x, property := hx })))
  else ↑(Bitvec.toNat (Vector.tail { val := true :: x, property := hx }))) =   bif true then Int.negSucc (Bitvec.toNat (Bitvec.not (Vector.tail { val := true :: y, property := hy })))
  else ↑(Bitvec.toNat (Vector.tail { val := true :: y, property := hy }))

a.true.true
Vector.toList { val := true :: x, property := hx } = Vector.toList { val := true :: y, property := hy }
n: β„•

x, y: List Bool

hx: List.length (false :: x) = n + 1

hy: List.length (false :: y) = n + 1

h: (Vector.toList ∘ Bitvec.ofNat n)
    (Bitvec.toNat { val := x, property := (_ : Nat.pred (List.length (false :: x)) = Nat.pred (Nat.succ (n + 0))) }) =   (Vector.toList ∘ Bitvec.ofNat n)
    (Bitvec.toNat { val := y, property := (_ : Nat.pred (List.length (false :: y)) = Nat.pred (Nat.succ (n + 0))) })

a.false.false
Vector.toList { val := false :: x, property := hx } = Vector.toList { val := false :: y, property := hy }
n: β„•

x, y: List Bool

hx: List.length (false :: x) = n + 1

hy: List.length (false :: y) = n + 1

h: (bif false then Int.negSucc (Bitvec.toNat (Bitvec.not (Vector.tail { val := false :: x, property := hx })))
  else ↑(Bitvec.toNat (Vector.tail { val := false :: x, property := hx }))) =   bif false then Int.negSucc (Bitvec.toNat (Bitvec.not (Vector.tail { val := false :: y, property := hy })))
  else ↑(Bitvec.toNat (Vector.tail { val := false :: y, property := hy }))

a.false.false
Vector.toList { val := false :: x, property := hx } = Vector.toList { val := false :: y, property := hy }
n: β„•

x, y: List Bool

hx: List.length (false :: x) = n + 1

hy: List.length (true :: y) = n + 1

h: (bif false then Int.negSucc (Bitvec.toNat (Bitvec.not (Vector.tail { val := false :: x, property := hx })))
  else ↑(Bitvec.toNat (Vector.tail { val := false :: x, property := hx }))) =   bif true then Int.negSucc (Bitvec.toNat (Bitvec.not (Vector.tail { val := true :: y, property := hy })))
  else ↑(Bitvec.toNat (Vector.tail { val := true :: y, property := hy }))

a.false.true
Vector.toList { val := false :: x, property := hx } = Vector.toList { val := true :: y, property := hy }
n: β„•

x, y: List Bool

hx: List.length (true :: x) = n + 1

hy: List.length (false :: y) = n + 1

h: (bif true then Int.negSucc (Bitvec.toNat (Bitvec.not (Vector.tail { val := true :: x, property := hx })))
  else ↑(Bitvec.toNat (Vector.tail { val := true :: x, property := hx }))) =   bif false then Int.negSucc (Bitvec.toNat (Bitvec.not (Vector.tail { val := false :: y, property := hy })))
  else ↑(Bitvec.toNat (Vector.tail { val := false :: y, property := hy }))

a.true.false
Vector.toList { val := true :: x, property := hx } = Vector.toList { val := false :: y, property := hy }
n: β„•

x, y: List Bool

hx: List.length (true :: x) = n + 1

hy: List.length (true :: y) = n + 1

h: (bif true then Int.negSucc (Bitvec.toNat (Bitvec.not (Vector.tail { val := true :: x, property := hx })))
  else ↑(Bitvec.toNat (Vector.tail { val := true :: x, property := hx }))) =   bif true then Int.negSucc (Bitvec.toNat (Bitvec.not (Vector.tail { val := true :: y, property := hy })))
  else ↑(Bitvec.toNat (Vector.tail { val := true :: y, property := hy }))

a.true.true
Vector.toList { val := true :: x, property := hx } = Vector.toList { val := true :: y, property := hy }
Goals accomplished! πŸ™
n: β„•

x, y: List Bool

hx: List.length (false :: x) = n + 1

hy: List.length (true :: y) = n + 1

h: (bif false then Int.negSucc (Bitvec.toNat (Bitvec.not (Vector.tail { val := false :: x, property := hx })))
  else ↑(Bitvec.toNat (Vector.tail { val := false :: x, property := hx }))) =   bif true then Int.negSucc (Bitvec.toNat (Bitvec.not (Vector.tail { val := true :: y, property := hy })))
  else ↑(Bitvec.toNat (Vector.tail { val := true :: y, property := hy }))

a.false.true
Vector.toList { val := false :: x, property := hx } = Vector.toList { val := true :: y, property := hy }
n: β„•

x, y: List Bool

hx: List.length (true :: x) = n + 1

hy: List.length (false :: y) = n + 1

h: (bif true then Int.negSucc (Bitvec.toNat (Bitvec.not (Vector.tail { val := true :: x, property := hx })))
  else ↑(Bitvec.toNat (Vector.tail { val := true :: x, property := hx }))) =   bif false then Int.negSucc (Bitvec.toNat (Bitvec.not (Vector.tail { val := false :: y, property := hy })))
  else ↑(Bitvec.toNat (Vector.tail { val := false :: y, property := hy }))

a.true.false
Vector.toList { val := true :: x, property := hx } = Vector.toList { val := false :: y, property := hy }
n: β„•

x, y: List Bool

hx: List.length (true :: x) = n + 1

hy: List.length (true :: y) = n + 1

h: (bif true then Int.negSucc (Bitvec.toNat (Bitvec.not (Vector.tail { val := true :: x, property := hx })))
  else ↑(Bitvec.toNat (Vector.tail { val := true :: x, property := hx }))) =   bif true then Int.negSucc (Bitvec.toNat (Bitvec.not (Vector.tail { val := true :: y, property := hy })))
  else ↑(Bitvec.toNat (Vector.tail { val := true :: y, property := hy }))

a.true.true
Vector.toList { val := true :: x, property := hx } = Vector.toList { val := true :: y, property := hy }
n: β„•

a: Bool

x: List Bool

hx: List.length (a :: x) = n + 1

b: Bool

y: List Bool

hy: List.length (b :: y) = n + 1

h: Bitvec.toInt { val := a :: x, property := hx } = Bitvec.toInt { val := b :: y, property := hy }

{ val := a :: x, property := hx } = { val := b :: y, property := hy }
n: β„•

x, y: List Bool

hx: List.length (false :: x) = n + 1

hy: List.length (true :: y) = n + 1

h: (bif false then Int.negSucc (Bitvec.toNat (Bitvec.not (Vector.tail { val := false :: x, property := hx })))
  else ↑(Bitvec.toNat (Vector.tail { val := false :: x, property := hx }))) =   bif true then Int.negSucc (Bitvec.toNat (Bitvec.not (Vector.tail { val := true :: y, property := hy })))
  else ↑(Bitvec.toNat (Vector.tail { val := true :: y, property := hy }))

a.false.true
Vector.toList { val := false :: x, property := hx } = Vector.toList { val := true :: y, property := hy }
n: β„•

x, y: List Bool

hx: List.length (false :: x) = n + 1

hy: List.length (true :: y) = n + 1

h: (bif false then Int.negSucc (Bitvec.toNat (Bitvec.not (Vector.tail { val := false :: x, property := hx })))
  else ↑(Bitvec.toNat (Vector.tail { val := false :: x, property := hx }))) =   bif true then Int.negSucc (Bitvec.toNat (Bitvec.not (Vector.tail { val := true :: y, property := hy })))
  else ↑(Bitvec.toNat (Vector.tail { val := true :: y, property := hy }))

a.false.true
Vector.toList { val := false :: x, property := hx } = Vector.toList { val := true :: y, property := hy }
n: β„•

x, y: List Bool

hx: List.length (true :: x) = n + 1

hy: List.length (false :: y) = n + 1

h: (bif true then Int.negSucc (Bitvec.toNat (Bitvec.not (Vector.tail { val := true :: x, property := hx })))
  else ↑(Bitvec.toNat (Vector.tail { val := true :: x, property := hx }))) =   bif false then Int.negSucc (Bitvec.toNat (Bitvec.not (Vector.tail { val := false :: y, property := hy })))
  else ↑(Bitvec.toNat (Vector.tail { val := false :: y, property := hy }))

a.true.false
Vector.toList { val := true :: x, property := hx } = Vector.toList { val := false :: y, property := hy }
n: β„•

x, y: List Bool

hx: List.length (true :: x) = n + 1

hy: List.length (true :: y) = n + 1

h: (bif true then Int.negSucc (Bitvec.toNat (Bitvec.not (Vector.tail { val := true :: x, property := hx })))
  else ↑(Bitvec.toNat (Vector.tail { val := true :: x, property := hx }))) =   bif true then Int.negSucc (Bitvec.toNat (Bitvec.not (Vector.tail { val := true :: y, property := hy })))
  else ↑(Bitvec.toNat (Vector.tail { val := true :: y, property := hy }))

a.true.true
Vector.toList { val := true :: x, property := hx } = Vector.toList { val := true :: y, property := hy }
Goals accomplished! πŸ™
n: β„•

x, y: List Bool

hx: List.length (true :: x) = n + 1

hy: List.length (false :: y) = n + 1

h: (bif true then Int.negSucc (Bitvec.toNat (Bitvec.not (Vector.tail { val := true :: x, property := hx })))
  else ↑(Bitvec.toNat (Vector.tail { val := true :: x, property := hx }))) =   bif false then Int.negSucc (Bitvec.toNat (Bitvec.not (Vector.tail { val := false :: y, property := hy })))
  else ↑(Bitvec.toNat (Vector.tail { val := false :: y, property := hy }))

a.true.false
Vector.toList { val := true :: x, property := hx } = Vector.toList { val := false :: y, property := hy }
n: β„•

x, y: List Bool

hx: List.length (true :: x) = n + 1

hy: List.length (true :: y) = n + 1

h: (bif true then Int.negSucc (Bitvec.toNat (Bitvec.not (Vector.tail { val := true :: x, property := hx })))
  else ↑(Bitvec.toNat (Vector.tail { val := true :: x, property := hx }))) =   bif true then Int.negSucc (Bitvec.toNat (Bitvec.not (Vector.tail { val := true :: y, property := hy })))
  else ↑(Bitvec.toNat (Vector.tail { val := true :: y, property := hy }))

a.true.true
Vector.toList { val := true :: x, property := hx } = Vector.toList { val := true :: y, property := hy }
n: β„•

a: Bool

x: List Bool

hx: List.length (a :: x) = n + 1

b: Bool

y: List Bool

hy: List.length (b :: y) = n + 1

h: Bitvec.toInt { val := a :: x, property := hx } = Bitvec.toInt { val := b :: y, property := hy }

{ val := a :: x, property := hx } = { val := b :: y, property := hy }
n: β„•

x, y: List Bool

hx: List.length (true :: x) = n + 1

hy: List.length (false :: y) = n + 1

h: (bif true then Int.negSucc (Bitvec.toNat (Bitvec.not (Vector.tail { val := true :: x, property := hx })))
  else ↑(Bitvec.toNat (Vector.tail { val := true :: x, property := hx }))) =   bif false then Int.negSucc (Bitvec.toNat (Bitvec.not (Vector.tail { val := false :: y, property := hy })))
  else ↑(Bitvec.toNat (Vector.tail { val := false :: y, property := hy }))

a.true.false
Vector.toList { val := true :: x, property := hx } = Vector.toList { val := false :: y, property := hy }
n: β„•

x, y: List Bool

hx: List.length (true :: x) = n + 1

hy: List.length (false :: y) = n + 1

h: (bif true then Int.negSucc (Bitvec.toNat (Bitvec.not (Vector.tail { val := true :: x, property := hx })))
  else ↑(Bitvec.toNat (Vector.tail { val := true :: x, property := hx }))) =   bif false then Int.negSucc (Bitvec.toNat (Bitvec.not (Vector.tail { val := false :: y, property := hy })))
  else ↑(Bitvec.toNat (Vector.tail { val := false :: y, property := hy }))

a.true.false
Vector.toList { val := true :: x, property := hx } = Vector.toList { val := false :: y, property := hy }
n: β„•

x, y: List Bool

hx: List.length (true :: x) = n + 1

hy: List.length (true :: y) = n + 1

h: (bif true then Int.negSucc (Bitvec.toNat (Bitvec.not (Vector.tail { val := true :: x, property := hx })))
  else ↑(Bitvec.toNat (Vector.tail { val := true :: x, property := hx }))) =   bif true then Int.negSucc (Bitvec.toNat (Bitvec.not (Vector.tail { val := true :: y, property := hy })))
  else ↑(Bitvec.toNat (Vector.tail { val := true :: y, property := hy }))

a.true.true
Vector.toList { val := true :: x, property := hx } = Vector.toList { val := true :: y, property := hy }
Goals accomplished! πŸ™
n: β„•

x, y: List Bool

hx: List.length (true :: x) = n + 1

hy: List.length (true :: y) = n + 1

h: (bif true then Int.negSucc (Bitvec.toNat (Bitvec.not (Vector.tail { val := true :: x, property := hx })))
  else ↑(Bitvec.toNat (Vector.tail { val := true :: x, property := hx }))) =   bif true then Int.negSucc (Bitvec.toNat (Bitvec.not (Vector.tail { val := true :: y, property := hy })))
  else ↑(Bitvec.toNat (Vector.tail { val := true :: y, property := hy }))

a.true.true
Vector.toList { val := true :: x, property := hx } = Vector.toList { val := true :: y, property := hy }
n: β„•

a: Bool

x: List Bool

hx: List.length (a :: x) = n + 1

b: Bool

y: List Bool

hy: List.length (b :: y) = n + 1

h: Bitvec.toInt { val := a :: x, property := hx } = Bitvec.toInt { val := b :: y, property := hy }

{ val := a :: x, property := hx } = { val := b :: y, property := hy }
n: β„•

x, y: List Bool

hx: List.length (true :: x) = n + 1

hy: List.length (true :: y) = n + 1

h: (bif true then Int.negSucc (Bitvec.toNat (Bitvec.not (Vector.tail { val := true :: x, property := hx })))
  else ↑(Bitvec.toNat (Vector.tail { val := true :: x, property := hx }))) =   bif true then Int.negSucc (Bitvec.toNat (Bitvec.not (Vector.tail { val := true :: y, property := hy })))
  else ↑(Bitvec.toNat (Vector.tail { val := true :: y, property := hy }))

a.true.true
Vector.toList { val := true :: x, property := hx } = Vector.toList { val := true :: y, property := hy }
n: β„•

x, y: List Bool

hx: List.length (true :: x) = n + 1

hy: List.length (true :: y) = n + 1

h: (bif true then Int.negSucc (Bitvec.toNat (Bitvec.not (Vector.tail { val := true :: x, property := hx })))
  else ↑(Bitvec.toNat (Vector.tail { val := true :: x, property := hx }))) =   bif true then Int.negSucc (Bitvec.toNat (Bitvec.not (Vector.tail { val := true :: y, property := hy })))
  else ↑(Bitvec.toNat (Vector.tail { val := true :: y, property := hy }))

a.true.true
Vector.toList { val := true :: x, property := hx } = Vector.toList { val := true :: y, property := hy }
n: β„•

x, y: List Bool

hx: List.length (true :: x) = n + 1

hy: List.length (true :: y) = n + 1

h: Bitvec.toNat
    (Bitvec.not { val := x, property := (_ : Nat.pred (List.length (true :: x)) = Nat.pred (Nat.succ (n + 0))) }) =   Bitvec.toNat
    (Bitvec.not { val := y, property := (_ : Nat.pred (List.length (true :: y)) = Nat.pred (Nat.succ (n + 0))) })

a.true.true
Vector.toList { val := true :: x, property := hx } = Vector.toList { val := true :: y, property := hy }
n: β„•

x, y: List Bool

hx: List.length (true :: x) = n + 1

hy: List.length (true :: y) = n + 1

h: (bif true then Int.negSucc (Bitvec.toNat (Bitvec.not (Vector.tail { val := true :: x, property := hx })))
  else ↑(Bitvec.toNat (Vector.tail { val := true :: x, property := hx }))) =   bif true then Int.negSucc (Bitvec.toNat (Bitvec.not (Vector.tail { val := true :: y, property := hy })))
  else ↑(Bitvec.toNat (Vector.tail { val := true :: y, property := hy }))

a.true.true
Vector.toList { val := true :: x, property := hx } = Vector.toList { val := true :: y, property := hy }
n: β„•

x, y: List Bool

hx: List.length (true :: x) = n + 1

hy: List.length (true :: y) = n + 1

h: (Vector.toList ∘ Bitvec.ofNat n)
    (Bitvec.toNat
      (Bitvec.not { val := x, property := (_ : Nat.pred (List.length (true :: x)) = Nat.pred (Nat.succ (n + 0))) })) =   (Vector.toList ∘ Bitvec.ofNat n)
    (Bitvec.toNat
      (Bitvec.not { val := y, property := (_ : Nat.pred (List.length (true :: y)) = Nat.pred (Nat.succ (n + 0))) }))

a.true.true
Vector.toList { val := true :: x, property := hx } = Vector.toList { val := true :: y, property := hy }
n: β„•

x, y: List Bool

hx: List.length (true :: x) = n + 1

hy: List.length (true :: y) = n + 1

h: (bif true then Int.negSucc (Bitvec.toNat (Bitvec.not (Vector.tail { val := true :: x, property := hx })))
  else ↑(Bitvec.toNat (Vector.tail { val := true :: x, property := hx }))) =   bif true then Int.negSucc (Bitvec.toNat (Bitvec.not (Vector.tail { val := true :: y, property := hy })))
  else ↑(Bitvec.toNat (Vector.tail { val := true :: y, property := hy }))

a.true.true
Vector.toList { val := true :: x, property := hx } = Vector.toList { val := true :: y, property := hy }
Goals accomplished! πŸ™
Goals accomplished! πŸ™


theorem 
toInt_zero: βˆ€ {w : β„•}, Bitvec.toInt 0 = 0
toInt_zero {
w: β„•
w : 
Nat: Type
Nat} : (
0: ?m.337976
0 : 
Bitvec: β„• β†’ Type
Bitvec 
w: β„•
w).
toInt: {n : β„•} β†’ Bitvec n β†’ β„€
toInt = 
0: ?m.338008
0 := 
Goals accomplished! πŸ™
w: β„•

Bitvec.toInt 0 = 0
w: β„•

(match w, 0 with
  | 0, x => 0
  | Nat.succ n, v =>
    bif Vector.head v then Int.negSucc (Bitvec.toNat (Bitvec.not (Vector.tail v)))
    else ↑(Bitvec.toNat (Vector.tail v))) =   0
w: β„•

Bitvec.toInt 0 = 0
zero
(match Nat.zero, 0 with
  | 0, x => 0
  | Nat.succ n, v =>
    bif Vector.head v then Int.negSucc (Bitvec.toNat (Bitvec.not (Vector.tail v)))
    else ↑(Bitvec.toNat (Vector.tail v))) =   0
w: β„•

succ
(match Nat.succ w, 0 with
  | 0, x => 0
  | Nat.succ n, v =>
    bif Vector.head v then Int.negSucc (Bitvec.toNat (Bitvec.not (Vector.tail v)))
    else ↑(Bitvec.toNat (Vector.tail v))) =   0
w: β„•

Bitvec.toInt 0 = 0
zero
(match Nat.zero, 0 with
  | 0, x => 0
  | Nat.succ n, v =>
    bif Vector.head v then Int.negSucc (Bitvec.toNat (Bitvec.not (Vector.tail v)))
    else ↑(Bitvec.toNat (Vector.tail v))) =   0
zero
(match Nat.zero, 0 with
  | 0, x => 0
  | Nat.succ n, v =>
    bif Vector.head v then Int.negSucc (Bitvec.toNat (Bitvec.not (Vector.tail v)))
    else ↑(Bitvec.toNat (Vector.tail v))) =   0
w: β„•

succ
(match Nat.succ w, 0 with
  | 0, x => 0
  | Nat.succ n, v =>
    bif Vector.head v then Int.negSucc (Bitvec.toNat (Bitvec.not (Vector.tail v)))
    else ↑(Bitvec.toNat (Vector.tail v))) =   0
Goals accomplished! πŸ™
w: β„•

Bitvec.toInt 0 = 0
w: β„•

succ
(match Nat.succ w, 0 with
  | 0, x => 0
  | Nat.succ n, v =>
    bif Vector.head v then Int.negSucc (Bitvec.toNat (Bitvec.not (Vector.tail v)))
    else ↑(Bitvec.toNat (Vector.tail v))) =   0
w: β„•

succ
(match Nat.succ w, 0 with
  | 0, x => 0
  | Nat.succ n, v =>
    bif Vector.head v then Int.negSucc (Bitvec.toNat (Bitvec.not (Vector.tail v)))
    else ↑(Bitvec.toNat (Vector.tail v))) =   0
w: β„•

this: Vector.head 0 = false

succ
(match Nat.succ w, 0 with
  | 0, x => 0
  | Nat.succ n, v =>
    bif Vector.head v then Int.negSucc (Bitvec.toNat (Bitvec.not (Vector.tail v)))
    else ↑(Bitvec.toNat (Vector.tail v))) =   0
w: β„•

succ
(match Nat.succ w, 0 with
  | 0, x => 0
  | Nat.succ n, v =>
    bif Vector.head v then Int.negSucc (Bitvec.toNat (Bitvec.not (Vector.tail v)))
    else ↑(Bitvec.toNat (Vector.tail v))) =   0
w: β„•

this✝: Vector.head 0 = false

this: Vector.tail 0 = 0

succ
(match Nat.succ w, 0 with
  | 0, x => 0
  | Nat.succ n, v =>
    bif Vector.head v then Int.negSucc (Bitvec.toNat (Bitvec.not (Vector.tail v)))
    else ↑(Bitvec.toNat (Vector.tail v))) =   0
w: β„•

succ
(match Nat.succ w, 0 with
  | 0, x => 0
  | Nat.succ n, v =>
    bif Vector.head v then Int.negSucc (Bitvec.toNat (Bitvec.not (Vector.tail v)))
    else ↑(Bitvec.toNat (Vector.tail v))) =   0
Goals accomplished! πŸ™


@[simp]
theorem 
toInt_eq_zero: βˆ€ {w : β„•} (b : Bitvec w), Bitvec.toInt b = 0 ↔ b = 0
toInt_eq_zero {
w: β„•
w : 
Nat: Type
Nat} (
b: Bitvec w
b : 
Bitvec: β„• β†’ Type
Bitvec 
w: β„•
w) : 
b: Bitvec w
b.
toInt: {n : β„•} β†’ Bitvec n β†’ β„€
toInt = 
0: ?m.340676
0 ↔ 
b: Bitvec w
b = 
0: ?m.340702
0 := 
Goals accomplished! πŸ™
w: β„•

b: Bitvec w

Bitvec.toInt b = 0 ↔ b = 0
w: β„•

b: Bitvec w

Bitvec.toInt b = 0 ↔ b = 0
w: β„•

b: Bitvec w

Bitvec.toInt b = 0 ↔ Bitvec.toInt b = Bitvec.toInt 0
w: β„•

b: Bitvec w

Bitvec.toInt b = 0 ↔ b = 0
w: β„•

b: Bitvec w

Bitvec.toInt b = 0 ↔ Bitvec.toInt b = 0
Goals accomplished! πŸ™


theorem 
toInt_one: βˆ€ {w : β„•}, 1 < w β†’ Bitvec.toInt 1 = 1
toInt_one : βˆ€ {
w: β„•
w : 
β„•: Type
β„•} (
_hw: 1 < w
_hw : 
1: ?m.340812
1 < 
w: β„•
w), 
Bitvec.toInt: {n : β„•} β†’ Bitvec n β†’ β„€
Bitvec.toInt (
1: ?m.340851
1 : 
Bitvec: β„• β†’ Type
Bitvec 
w: β„•
w) = 
1: ?m.340876
1 
  | 
w: β„•
w+2, _ => 
Goals accomplished! πŸ™
w: β„•

x✝: 1 < w + 2

Bitvec.toInt 1 = 1
w: β„•

x✝: 1 < w + 2

this: Vector.head 1 = false

Bitvec.toInt 1 = 1
w: β„•

x✝: 1 < w + 2

Bitvec.toInt 1 = 1
w: β„•

x✝: 1 < w + 2

this✝: Vector.head 1 = false

this: Vector.tail 1 = 1

Bitvec.toInt 1 = 1
w: β„•

x✝: 1 < w + 2

Bitvec.toInt 1 = 1
Goals accomplished! πŸ™


-- from InstCombine/:805
theorem 
Warning: declaration uses 'sorry'
 {
w: β„•
w : 
Nat: Type
Nat} {
x: Bitvec w
x : 
Bitvec: β„• β†’ Type
Bitvec 
w: β„•
w} (
hw: w > 1
hw : 
w: β„•
w > 
1: ?m.343603
1) (
hx: x β‰  0
hx : 
x: Bitvec w
x β‰  
0: ?m.343636
0) :
  
Bitvec.sdiv?: {w : β„•} β†’ Bitvec w β†’ Bitvec w β†’ Option (Bitvec w)
Bitvec.sdiv? 
1: ?m.343664
1 
x: Bitvec w
x = 
Option.some: {Ξ± : Type ?u.343687} β†’ Ξ± β†’ Option Ξ±
Option.some (
Bitvec.select: {w : β„•} β†’ Bitvec 1 β†’ Bitvec w β†’ Bitvec w β†’ Bitvec w
Bitvec.select 
    (((
x: Bitvec w
x + 
1: ?m.343700
1).
toNat: {n : β„•} β†’ Bitvec n β†’ β„•
toNat < 
3: ?m.343776
3) ::α΅₯ 
Vector.nil: {Ξ± : Type ?u.343828} β†’ Vector Ξ± 0
Vector.nil) 
x: Bitvec w
x 
0: ?m.343831
0) := 
Goals accomplished! πŸ™
w: β„•

x: Bitvec w

hw: w > 1

hx: x β‰  0

sdiv? 1 x = some (select (decide (Bitvec.toNat (x + 1) < 3) ::α΅₯ Vector.nil) x 0)
w: β„•

x: Bitvec w

hw: w > 1

hx: x β‰  0

sdiv? 1 x = some (select (decide (Bitvec.toNat (x + 1) < 3) ::α΅₯ Vector.nil) x 0)
Goals accomplished! πŸ™
w: β„•

x: Bitvec w

hw: w > 1

hx: x β‰  0

w β‰  0
x: Bitvec 0

hw: 0 > 1

hx: x β‰  0

False
x: Bitvec 0

hw: 0 > 1

hx: x β‰  0

False
w: β„•

x: Bitvec w

hw: w > 1

hx: x β‰  0

w β‰  0
Goals accomplished! πŸ™
w: β„•

x: Bitvec w

hw: w > 1

hx: x β‰  0

sdiv? 1 x = some (select (decide (Bitvec.toNat (x + 1) < 3) ::α΅₯ Vector.nil) x 0)
w: β„•

x: Bitvec w

hw: w > 1

hx: x β‰  0

hw0: w β‰  0

ofInt' w (1 / Bitvec.toInt x) = if (Bitvec.toNat x + 1) % 2 ^ w < 3 then x else 0
w: β„•

x: Bitvec w

hw: w > 1

hx: x β‰  0

sdiv? 1 x = some (select (decide (Bitvec.toNat (x + 1) < 3) ::α΅₯ Vector.nil) x 0)
Goals accomplished! πŸ™


end Bitvec